Sequelize Mastery: Automating SQL Model Design

JSON to Sequelize Model: Generating ORM Definitions from JSON Payloads

Sequelize is the most widely used Node.js ORM, powering Express and Fastify APIs on PostgreSQL, MySQL, SQLite, and MariaDB. When you have a JSON payload and need to persist it, generating the Sequelize model definition saves the tedious work of mapping field types to DataTypes, configuring allowNull, and writing the Model.init() call by hand.

Live Example: Blog Post Model

// Input JSON
{
  "title": "Getting Started with TypeScript",
  "slug": "getting-started-typescript",
  "body": "TypeScript adds static types to JavaScript...",
  "author_id": "usr_881",
  "view_count": 4201,
  "is_published": true,
  "published_at": "2024-09-15T10:00:00Z",
  "tags": ["typescript", "javascript"]
}

// Generated Sequelize Model
import { DataTypes, Model } from 'sequelize';
import sequelize from '../config/database';

export class Root extends Model {}

Root.init({
  id: {
    type: DataTypes.UUID,
    defaultValue: DataTypes.UUIDV4,
    primaryKey: true
  },
  title:        { type: DataTypes.STRING,  allowNull: false },
  slug:         { type: DataTypes.STRING,  allowNull: false },
  body:         { type: DataTypes.STRING,  allowNull: false },
  author_id:    { type: DataTypes.STRING,  allowNull: false },
  view_count:   { type: DataTypes.DOUBLE,  allowNull: false },
  is_published: { type: DataTypes.BOOLEAN, allowNull: false },
  published_at: { type: DataTypes.DATE,    allowNull: false },
  tags:         { type: DataTypes.JSON,    allowNull: false },
}, {
  sequelize,
  modelName: 'Root',
  tableName: 'roots',
  timestamps: true
});

What to Refine After Generation

Rename the model and table, use TEXT for long strings, INTEGER for counts:

import { DataTypes, Model, Optional } from 'sequelize';
import sequelize from '../config/database';

interface PostAttributes {
  id: string;
  title: string;
  slug: string;
  body: string;
  author_id: string;
  view_count: number;
  is_published: boolean;
  published_at: Date;
  tags: string[];
}

type PostCreationAttributes = Optional<PostAttributes, 'id' | 'view_count'>;

export class Post extends Model<PostAttributes, PostCreationAttributes>
  implements PostAttributes {
  declare id: string;
  declare title: string;
  declare slug: string;
  declare body: string;
  declare author_id: string;
  declare view_count: number;
  declare is_published: boolean;
  declare published_at: Date;
  declare tags: string[];
}

Post.init({
  id:           { type: DataTypes.UUID, defaultValue: DataTypes.UUIDV4, primaryKey: true },
  title:        { type: DataTypes.STRING(500), allowNull: false },
  slug:         { type: DataTypes.STRING, allowNull: false, unique: true },
  body:         { type: DataTypes.TEXT, allowNull: false },       // TEXT not STRING
  author_id:    { type: DataTypes.UUID, allowNull: false },
  view_count:   { type: DataTypes.INTEGER, defaultValue: 0 },    // INTEGER not DOUBLE
  is_published: { type: DataTypes.BOOLEAN, defaultValue: false },
  published_at: { type: DataTypes.DATE, allowNull: true },
  tags:         { type: DataTypes.ARRAY(DataTypes.STRING), defaultValue: [] }, // PG only
}, {
  sequelize,
  modelName: 'Post',
  tableName: 'posts',
  timestamps: true,   // adds createdAt / updatedAt automatically
  paranoid: true,     // adds deletedAt for soft-delete support
});

Adding Associations

import { Post } from './post.model';
import { User } from './user.model';

// One user has many posts
User.hasMany(Post, { foreignKey: 'author_id', as: 'posts' });
Post.belongsTo(User, { foreignKey: 'author_id', as: 'author' });

// Query with eager loading
const post = await Post.findOne({
  where: { slug: 'getting-started-typescript' },
  include: [{ model: User, as: 'author', attributes: ['id', 'name', 'email'] }]
});
console.log(post?.author.name); // TypeScript-typed via declare

Sequelize vs TypeORM vs Prisma

• Sequelize: Model.init() style, JavaScript-first, works great with plain JS projects. Best documented for MySQL/MariaDB. Requires manual type declarations for full TypeScript support.
• TypeORM: Decorator-based (@Entity, @Column), TypeScript-first. Closer to Java's JPA. Better IDE support out of the box.
• Prisma: Schema-first (schema.prisma file), no model classes — the generated client is the ORM. Fastest DX, best type safety, but schema migrations are Prisma-controlled.

Frequently Asked Questions

Where does the sequelize import come from? Create a database config file: export default new Sequelize(process.env.DATABASE_URL!, { dialect: 'postgres', logging: false }); and import it into your models.

Does timestamps: true add the columns automatically? Yes — Sequelize adds createdAt and updatedAt columns and manages them automatically. You don't need to define them in Model.init().

How does paranoid: true work? Instead of deleting rows, Sequelize sets deletedAt to the current timestamp. All queries automatically exclude soft-deleted rows. Call Model.restore() to undelete.

Is my JSON sent to a server? No. TypeMorph runs entirely in your browser — none of your data leaves your machine.