Defining models

import { Prorm, DataTypes } from 'ts-prorm-orm';

const prorm = new Prorm({ dialect: 'sqlite', storage: ':memory:' });
await prorm.connect();

const User = prorm.define(
  'User',
  {
    id: { type: DataTypes.INTEGER(), primaryKey: true, autoIncrement: true },
    name: { type: DataTypes.STRING(100), allowNull: false },
    email: { type: DataTypes.STRING(255), allowNull: false, unique: true },
    role: { type: DataTypes.ENUM('admin', 'user'), defaultValue: 'user' },
    bio: { type: DataTypes.TEXT() },
    age: { type: DataTypes.INTEGER() },
    meta: { type: DataTypes.JSON() },
  },
  { tableName: 'users', timestamps: true },
);

await prorm.sync();

src/
  db/
    index.ts        # creates the Prorm, calls every define*, then sync()
    models/
      user.ts       # defineUser(prorm)
      post.ts       # definePost(prorm)
  server.ts

import { DataTypes, type Prorm } from 'ts-prorm-orm';

export function defineUser(prorm: Prorm) {
  return prorm.define(
    'User',
    {
      id: { type: DataTypes.INTEGER(), primaryKey: true, autoIncrement: true },
      email: {
        type: DataTypes.STRING(255),
        allowNull: false,
        unique: true,
        validate: { isEmail: true },
      },
      name: { type: DataTypes.STRING(100), allowNull: false },
      role: { type: DataTypes.ENUM('admin', 'member', 'viewer'), defaultValue: 'member' },
      passwordHash: { type: DataTypes.STRING(255), hidden: true },
      lastLoginAt: { type: DataTypes.DATE() },
    },
    {
      tableName: 'users',
      paranoid: true,
      indexes: [{ fields: ['role'] }],
    },
  );
}

import { Prorm } from 'ts-prorm-orm';
import { defineUser } from './models/user';
import { definePost } from './models/post';

export const prorm = new Prorm({
  dialect: 'postgres',
  host: process.env.PGHOST,
  database: process.env.PGDATABASE,
  username: process.env.PGUSER,
  password: process.env.PGPASSWORD,
});

export const User = defineUser(prorm);
export const Post = definePost(prorm);

User.hasMany(Post, { foreignKey: 'authorId', as: 'posts' });
Post.belongsTo(User, { foreignKey: 'authorId', as: 'author' });

export async function initDb() {
  await prorm.connect();
  if (process.env.NODE_ENV !== 'production') await prorm.sync();
}

const Tag = prorm.define('Tag', {
  label: DataTypes.STRING(50), // same as { type: DataTypes.STRING(50) }
  slug: { type: DataTypes.STRING(60), allowNull: false, unique: true },
  createdBy: { type: DataTypes.INTEGER(), references: { model: 'users', key: 'id' } },
});

import { Prorm } from 'ts-prorm-orm';

const config = {
  dialect: 'postgres' as const,
  database: 'app',
  // `define` is read at runtime but is not declared on PrormOptions yet,
  // so pass the config through a variable rather than an inline literal.
  define: { timestamps: true, paranoid: true },
};
const prorm = new Prorm(config);

const Tag = prorm.define('Tag', { label: DataTypes.STRING(50) }, { timestamps: false });

const User = prorm.define('User', {
  id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true, field: 'user_id' },
  email: { type: DataTypes.STRING, unique: true, field: 'email_address' },
});

await User.create({ email: 'ann@example.com' });
// INSERT INTO "users" ("email_address") VALUES (?)
await User.findAll({ attributes: ['id', 'email'], where: { email: { [Op.like]: '%@example.com' } } });
// SELECT "user_id" AS "id", "email_address" AS "email" FROM "users" WHERE "email_address" LIKE ?

import { Op } from 'ts-prorm-orm';

const lastWeek = await User.findAll({
  where: { createdAt: { [Op.gte]: new Date(Date.now() - 7 * 86_400_000) } },
  order: [['createdAt', 'DESC']],
});

// Instance save: every attribute, including the stamps, is written back.
const grace = await User.findByPk(7);
grace.name = 'Grace';
await grace.save();

// Static update: the columns you pass, plus the updatedAt stamp.
await User.update({ age: 31 }, { where: { id: 7 } });

// silent: true leaves updatedAt alone.
await User.update({ age: 31 }, { where: { id: 7 }, silent: true });

prorm.define('Event', { name: DataTypes.STRING(50) }, {
  tableName: 'events',
  createdAt: 'created_on',
});

const attrs = {
  id: { type: DataTypes.INTEGER(), primaryKey: true, autoIncrement: true },
  name: { type: DataTypes.STRING(100), allowNull: false },
};
const User = prorm.define('User', attrs, { tableName: 'users', paranoid: true });

await User.destroy({ where: { id: 1 } });
await User.findAll();                                  // excludes the row
await User.findAll({ paranoid: false });               // includes it
await User.restore({ where: { id: 1 } });
await User.count();                                    // aggregates honour it too
await User.destroy({ where: { id: 1 }, force: true }); // a real DELETE

import { Table, Column, PrimaryKey, AutoIncrement, AllowNull, Unique, Default, Field, DataTypes, Model } from 'ts-prorm-orm';

@Table({ tableName: 'users', timestamps: true, paranoid: true })
class User extends Model {
  @PrimaryKey
  @AutoIncrement
  @Column(DataTypes.INTEGER())
  id!: number;

  @AllowNull(false)
  @Column(DataTypes.STRING(100))
  name!: string;

  @Unique
  @Column(DataTypes.STRING(255))
  email!: string;

  @Default('user')
  @Column(DataTypes.ENUM('admin', 'user'))
  role!: string;

  // Stored in the `display_name` column. `@Column({ type, field })` does the same.
  @Field('display_name')
  @Column(DataTypes.STRING(100))
  displayName!: string;
}

const UserModel = prorm.addModel(User);
await prorm.sync();

const User = prorm.define('User', attrs, {
  tableName: 'users',
  classMethods: {
    async findByEmail(this: ModelStatic, email: string) {
      return this.findOne({ where: { email } });
    },
  },
  instanceMethods: {
    displayName(this: { name: string; email: string }) {
      return `${this.name} <${this.email}>`;
    },
  },
});

const u = await User.findByEmail('ada@example.com');
u.displayName();

const described = await User.describe();
const missing = Object.keys(User.getAttributes()).filter((name) => !(name in described));
if (missing.length) {
  throw new Error(`users is missing column(s): ${missing.join(', ')}; run the migrations`);
}

prorm.define('User', {
  id: { type: DataTypes.INTEGER(), primaryKey: true, autoIncrement: true },
  name: { type: DataTypes.STRING(100), allowNull: false }, // was nullable
  email: DataTypes.STRING(255),                            // new
  // nickname: removed from the model
}, { tableName: 'users' });

await prorm.sync({ alter: true });
await prorm.sync({ alter: { drop: 'soft' } });