Importing a Prisma schema

$ npx prorm prisma:import --schema ./prisma/schema.prisma --models-out ./src/models --migrations-out ./migrations
Created model: src/models/User.ts
Created model: src/models/Post.ts
Created model registry: src/models/index.ts
Created migration: migrations/1790460002759-prisma-import.js
Converted 2 model(s) from ./prisma/schema.prisma. Review the generated files — see the comment at the top of the migration file for what was translated on a best-effort basis.

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

enum Role {
  USER
  ADMIN
}

model User {
  id        Int      @id @default(autoincrement())
  email     String   @unique
  name      String?
  role      Role     @default(USER)
  posts     Post[]
  createdAt DateTime @default(now())
}

model Post {
  id        Int      @id @default(autoincrement())
  title     String
  body      String?
  published Boolean  @default(false)
  author    User     @relation(fields: [authorId], references: [id])
  authorId  Int
}

$ npx prorm prisma:import --schema ./prisma/schema.prisma --models-out ./src/models --migrations-out ./migrations

prisma/
  schema.prisma                    # unchanged: the import only reads it
src/
  models/
    User.ts                        # @Table class, @HasMany(() => Post)
    Post.ts                        # @BelongsTo(() => User), authorId: ForeignKey<number>
    index.ts                       # export { User, Post } and registerModels()
migrations/
  1790460002759-prisma-import.js   # createTable x2, addConstraint x1

type Role = 'USER' | 'ADMIN';

@Table({ tableName: 'User', timestamps: false })
export class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
  @Attribute(DataTypes.INTEGER())
  @PrimaryKey()
  @AutoIncrement()
  declare id: CreationOptional<number>;

  @Attribute(DataTypes.STRING(191))
  @Unique()
  @NotNull()
  declare email: string;

  @Attribute(DataTypes.STRING(191))
  declare name: string | null;

  @Attribute(DataTypes.ENUM('USER', 'ADMIN'))
  @Default('USER')
  @NotNull()
  declare role: CreationOptional<Role>;

  @Attribute(DataTypes.DATE())
  @Default(DataTypes.NOW)
  @NotNull()
  declare createdAt: CreationOptional<Date>;

  @HasMany(() => Post, { foreignKey: 'authorId', as: 'posts' })
  declare posts: HasMany<Post>;
}

@Table({ tableName: 'Post', timestamps: false })
export class Post extends Model<InferAttributes<Post>, InferCreationAttributes<Post>> {
  @Attribute(DataTypes.INTEGER())
  @PrimaryKey()
  @AutoIncrement()
  declare id: CreationOptional<number>;

  @Attribute(DataTypes.STRING(191))
  @NotNull()
  declare title: string;

  @Attribute(DataTypes.STRING(191))
  declare body: string | null;

  @Attribute(DataTypes.BOOLEAN())
  @Default(false)
  @NotNull()
  declare published: CreationOptional<boolean>;

  @Attribute(DataTypes.INTEGER())
  @NotNull()
  declare authorId: ForeignKey<number>;

  @BelongsTo(() => User, { foreignKey: 'authorId', as: 'author' })
  declare author: BelongsTo<User>;
}

$ prorm migration:run

import { convertPrismaSchema, parsePrismaSchema, resolveRelations } from 'ts-prorm-orm';

const { models, modelsIndex, migration } = convertPrismaSchema(schemaSource);
// models: { name, source }[]   modelsIndex: string   migration: string

import fs from 'node:fs';
import path from 'node:path';
import { convertPrismaSchema, parsePrismaSchema } from 'ts-prorm-orm';

const source = fs.readFileSync('prisma/schema.prisma', 'utf8');

// Inspect first: which models and enums are there?
const parsed = parsePrismaSchema(source);
console.log(`${parsed.models.length} models, ${parsed.enums.length} enums`);

// Throws, naming the model and field, on anything it will not guess at.
const { models, modelsIndex, migration } = convertPrismaSchema(source);

const outDir = 'packages/db/src/models';
fs.mkdirSync(outDir, { recursive: true });
const fix = (code: string) => code.replaceAll("'prorm'", "'ts-prorm-orm'");
for (const m of models) fs.writeFileSync(path.join(outDir, `${m.name}.ts`), fix(m.source));
fs.writeFileSync(path.join(outDir, 'index.ts'), fix(modelsIndex));
fs.writeFileSync(`packages/db/migrations/${Date.now()}-prisma-import.js`, fix(migration));

model Post {
  id   Int   @id @default(autoincrement())
  tags Tag[]
}

model Tag {
  id    Int    @id @default(autoincrement())
  posts Post[]
}

$ npx prorm prisma:import --schema ./prisma/schema.prisma
Error converting schema: prisma-migrate: relation between "Post" and "Tag" has no side declaring @relation(fields: [...], references: [...]) — can't determine which side owns the foreign key. This looks like an implicit many-to-many relation (both sides are plain arrays with no @relation attribute) — those aren't supported; add an explicit join model instead.

import { Prorm } from 'ts-prorm-orm';
import { registerModels, User, Post } from './models';

const prorm = new Prorm({ dialect: 'postgres', url: process.env.DATABASE_URL });
registerModels(prorm); // calls prorm.addModels([User, Post])
await prorm.connect();

const ada = await User.create({ email: 'ada@example.com', name: 'Ada' });
await Post.create({ title: 'Notes', authorId: ada.id });