ts-prorm-orm 1.1.0

package/dist/prisma-migrate/index.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * Prisma schema.prisma → prorm converter. Pure functions only (no
+ * filesystem access) so this is unit-testable without touching disk — the
+ * CLI layer (see cli.ts's `prisma:import` command) owns reading the input
+ * file and writing the generated output.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRelations = exports.parsePrismaSchema = void 0;
+exports.convertPrismaSchema = convertPrismaSchema;
+const schema_parser_1 = require("./schema-parser");
+const model_generator_1 = require("./model-generator");
+const migration_generator_1 = require("./migration-generator");
+const relations_1 = require("./relations");
+var schema_parser_2 = require("./schema-parser");
+Object.defineProperty(exports, "parsePrismaSchema", { enumerable: true, get: function () { return schema_parser_2.parsePrismaSchema; } });
+var relations_2 = require("./relations");
+Object.defineProperty(exports, "resolveRelations", { enumerable: true, get: function () { return relations_2.resolveRelations; } });
+/**
+ * @throws if the schema uses a feature this tool doesn't support: implicit
+ * many-to-many relations, composite foreign keys, or a Prisma scalar type
+ * with no prorm equivalent (see relations.ts / type-mapper.ts for the exact
+ * conditions) — these throw rather than emit incorrect/guessed output.
+ */
+function convertPrismaSchema(schemaSource) {
+    const schema = (0, schema_parser_1.parsePrismaSchema)(schemaSource);
+    const modelNames = new Set(schema.models.map((m) => m.name));
+    const relations = (0, relations_1.resolveRelations)(schema.models, modelNames);
+    const models = schema.models.map((model) => ({
+        name: model.name,
+        source: (0, model_generator_1.generateModelFile)(model, schema.models, schema.enums, relations),
+    }));
+    return {
+        models,
+        modelsIndex: (0, model_generator_1.generateModelsIndex)(schema.models),
+        migration: (0, migration_generator_1.generateInitialMigration)(schema.models, schema.enums, relations),
+    };
+}

package/dist/prisma-migrate/migration-generator.js

@@ -0,0 +1,125 @@
+"use strict";
+/**
+ * Generates a single "initial schema" prorm migration file from a parsed
+ * Prisma schema, using the QueryInterface API (see src/migrations/
+ * query-interface.ts and docs-next/docs/example/advanced/06-migrations.ts
+ * for the real shape this mirrors).
+ *
+ * Strategy: create every table with its scalar columns first (no foreign
+ * keys inline), then add every foreign key as a separate `addConstraint`
+ * call in a second pass. This sidesteps needing a topological sort over
+ * model dependencies — table creation order genuinely doesn't matter when
+ * no table references another yet.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateInitialMigration = generateInitialMigration;
+const type_mapper_1 = require("./type-mapper");
+function columnDefExpr(field, enumsByName, isPrimaryKey) {
+    const { dataTypeExpr } = (0, type_mapper_1.mapPrismaType)(field.type, enumsByName);
+    const props = [`type: ${dataTypeExpr}`];
+    if (isPrimaryKey)
+        props.push('primaryKey: true');
+    if (!field.isOptional)
+        props.push('allowNull: false');
+    const defaultAttr = field.attributes.find((a) => a.name === 'default');
+    if (defaultAttr) {
+        const raw = defaultAttr.rawArgs.trim();
+        if (raw === 'autoincrement()') {
+            props.push('autoIncrement: true');
+        }
+        else if (raw === 'now()') {
+            props.push("defaultValue: prorm.literal('CURRENT_TIMESTAMP')");
+        }
+        else if (raw === 'uuid()' || raw === 'cuid()') {
+            props.push('defaultValue: DataTypes.UUIDV4');
+        }
+        else {
+            // Numeric/boolean/string/enum-member literal — same forms resolveDefault()
+            // in model-generator.ts accepts, reused here as a plain SQL-ish JS value.
+            props.push(`defaultValue: ${/^\w+$/.test(raw) && !/^-?\d+(\.\d+)?$/.test(raw) && raw !== 'true' && raw !== 'false' ? `'${raw}'` : raw}`);
+        }
+    }
+    if (field.attributes.some((a) => a.name === 'unique'))
+        props.push('unique: true');
+    return `{ ${props.join(', ')} }`;
+}
+/** Generates one model's `createTable(...)` call body. */
+function generateCreateTable(model, allModels, enums) {
+    const enumsByName = new Map(enums.map((e) => [e.name, e.values]));
+    const modelNames = new Set(allModels.map((m) => m.name));
+    const mapAttr = model.blockAttributes.find((a) => a.name === 'map');
+    const tableName = mapAttr ? mapAttr.rawArgs.replace(/"/g, '') : model.name;
+    const idFieldNames = new Set(model.blockAttributes
+        .filter((a) => a.name === 'id')
+        .flatMap((a) => a.rawArgs.replace(/\[|\]/g, '').split(',').map((s) => s.trim()))
+        .filter(Boolean));
+    const columns = model.fields
+        .filter((f) => !modelNames.has(f.type)) // skip relation fields, keep plain FK scalar columns
+        .map((f) => {
+        const isPk = f.attributes.some((a) => a.name === 'id') || idFieldNames.has(f.name);
+        return `      ${f.name}: ${columnDefExpr(f, enumsByName, isPk)},`;
+    })
+        .join('\n');
+    return `    await queryInterface.createTable('${tableName}', {\n${columns}\n    });`;
+}
+function tableNameFor(model) {
+    const mapAttr = model.blockAttributes.find((a) => a.name === 'map');
+    return mapAttr ? mapAttr.rawArgs.replace(/"/g, '') : model.name;
+}
+function generateAddConstraint(rel, modelsByName) {
+    const sourceTable = tableNameFor(rel.model);
+    const targetTable = tableNameFor(modelsByName.get(rel.targetModel));
+    const constraintName = `${sourceTable}_${rel.foreignKey}_fk`;
+    return (`    await queryInterface.addConstraint('${sourceTable}', ['${rel.foreignKey}'], {\n` +
+        `      type: 'foreign key',\n` +
+        `      name: '${constraintName}',\n` +
+        `      references: { table: '${targetTable}', field: 'id' },\n` +
+        `      onUpdate: 'CASCADE',\n` +
+        `      onDelete: 'CASCADE',\n` +
+        `    });`);
+}
+function generateRemoveConstraint(rel) {
+    const sourceTable = tableNameFor(rel.model);
+    const constraintName = `${sourceTable}_${rel.foreignKey}_fk`;
+    return `    await queryInterface.removeConstraint('${sourceTable}', '${constraintName}');`;
+}
+/**
+ * Generates the full migration file source (CommonJS, matching
+ * buildMigrationTemplate's output shape in src/migrations/migration.ts) for
+ * every model + relation in the schema, as a single "initial schema"
+ * migration.
+ */
+function generateInitialMigration(models, enums, relations) {
+    const modelsByName = new Map(models.map((m) => [m.name, m]));
+    const belongsToRelations = relations.filter((r) => r.kind === 'belongsTo');
+    const createTableCalls = models.map((m) => generateCreateTable(m, models, enums)).join('\n\n');
+    const addConstraintCalls = belongsToRelations.map((r) => generateAddConstraint(r, modelsByName)).join('\n\n');
+    const removeConstraintCalls = belongsToRelations.map(generateRemoveConstraint).join('\n');
+    const dropTableCalls = [...models]
+        .reverse()
+        .map((m) => `    await queryInterface.dropTable('${tableNameFor(m)}');`)
+        .join('\n');
+    return `/**
+ * Auto-generated by prisma-migrate from schema.prisma. Review before running
+ * — in particular the foreign key naming, enum defaults, and any @updatedAt
+ * fields (see the comments left in the generated model files) were
+ * translated on a best-effort basis and are worth double-checking against
+ * your actual schema before this runs against a real database.
+ */
+const { DataTypes } = require('prorm');
+
+module.exports = {
+  up: async (queryInterface, prorm) => {
+${createTableCalls}
+
+${addConstraintCalls || '    // No relations to wire up.'}
+  },
+
+  down: async (queryInterface, prorm) => {
+${removeConstraintCalls || '    // No relations were added.'}
+
+${dropTableCalls}
+  },
+};
+`;
+}

package/dist/prisma-migrate/model-generator.js

@@ -0,0 +1,172 @@
+"use strict";
+/**
+ * Generates prorm decorator-based model source files (`@Table`/`@Attribute`/
+ * `@PrimaryKey()`/etc., the actively-maintained model API — see
+ * src/models/decorators.ts, not the orphaned `src/decorators/` set) from a
+ * parsed Prisma schema.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateModelFile = generateModelFile;
+exports.generateModelsIndex = generateModelsIndex;
+const type_mapper_1 = require("./type-mapper");
+/** Translates a Prisma `@default(...)` argument into either a prorm decorator override or a `@Default(...)` value expression. */
+function resolveDefault(rawArgs, prismaType) {
+    const trimmed = rawArgs.trim();
+    if (trimmed === 'autoincrement()') {
+        return { decoratorOverride: '@AutoIncrement()', valueExpr: null };
+    }
+    if (trimmed === 'now()') {
+        return { decoratorOverride: null, valueExpr: 'DataTypes.NOW' };
+    }
+    if (trimmed === 'uuid()' || trimmed === 'cuid()') {
+        // prorm has no cuid() generator; uuid v4 is the closest built-in and
+        // this is flagged in the generated comment rather than silently
+        // swapping ID formats without telling the caller.
+        return { decoratorOverride: null, valueExpr: 'DataTypes.UUIDV4' };
+    }
+    if (trimmed === 'true' || trimmed === 'false') {
+        return { decoratorOverride: null, valueExpr: trimmed };
+    }
+    if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+        return { decoratorOverride: null, valueExpr: trimmed };
+    }
+    if (/^"[^"]*"$/.test(trimmed)) {
+        return { decoratorOverride: null, valueExpr: trimmed };
+    }
+    // A bare identifier for an enum default (e.g. @default(ADMIN)) — Prisma
+    // enum member names are used as their own SQL values in prorm's ENUM type.
+    if (/^\w+$/.test(trimmed)) {
+        return { decoratorOverride: null, valueExpr: `'${trimmed}'` };
+    }
+    throw new Error(`prisma-migrate: don't know how to translate @default(${rawArgs}) for a ${prismaType} field — ` +
+        `unrecognized default-value expression. Remove the @default or set it manually in the generated model.`);
+}
+function pascalCase(name) {
+    return name.charAt(0).toUpperCase() + name.slice(1);
+}
+function propertyType(field, tsScalarType) {
+    const base = field.isOptional ? `${tsScalarType} | null` : tsScalarType;
+    return field.attributes.some((a) => a.name === 'id' || a.name === 'default')
+        ? `CreationOptional<${base}>`
+        : base;
+}
+const TS_SCALAR_TYPES = {
+    String: 'string',
+    Int: 'number',
+    BigInt: 'bigint',
+    Float: 'number',
+    Decimal: 'number',
+    Boolean: 'boolean',
+    DateTime: 'Date',
+    Json: 'unknown',
+    Bytes: 'Buffer',
+};
+function generateScalarField(field, enumsByName, isForeignKeyColumn) {
+    const { dataTypeExpr, isEnum } = (0, type_mapper_1.mapPrismaType)(field.type, enumsByName);
+    const decorators = [`@Attribute(${dataTypeExpr})`];
+    const idAttr = field.attributes.find((a) => a.name === 'id');
+    const defaultAttr = field.attributes.find((a) => a.name === 'default');
+    const uniqueAttr = field.attributes.find((a) => a.name === 'unique');
+    const updatedAtAttr = field.attributes.find((a) => a.name === 'updatedAt');
+    if (idAttr)
+        decorators.push('@PrimaryKey()');
+    let defaultOverrideDecorator = null;
+    if (defaultAttr) {
+        const resolved = resolveDefault(defaultAttr.rawArgs, field.type);
+        if (resolved.decoratorOverride) {
+            defaultOverrideDecorator = resolved.decoratorOverride;
+        }
+        else {
+            decorators.push(`@Default(${resolved.valueExpr})`);
+        }
+    }
+    if (defaultOverrideDecorator)
+        decorators.push(defaultOverrideDecorator);
+    if (uniqueAttr)
+        decorators.push('@Unique()');
+    if (!field.isOptional && !idAttr)
+        decorators.push('@NotNull()');
+    const tsType = isEnum
+        ? field.type // reuse the Prisma enum's own name as a TS union alias name; see the emitted `type <Enum> = ...` companion
+        : TS_SCALAR_TYPES[field.type] || 'unknown';
+    const declareType = propertyType(field, tsType);
+    const comment = updatedAtAttr
+        ? '  // @updatedAt in Prisma: prorm has no auto-touch-on-save decorator for an arbitrary column (only the built-in updatedAt timestamp column via @Table({ timestamps: true })) — update this field manually or wire it through Table({ updatedAt: \'' +
+            field.name +
+            "' }) if this is meant to be the model's standard updated-at column.\n"
+        : '';
+    const foreignKeyTypeWrap = isForeignKeyColumn ? `ForeignKey<${tsType}>` : declareType;
+    return `${comment}  ${decorators.join('\n  ')}\n  declare ${field.name}: ${foreignKeyTypeWrap};`;
+}
+function generateAssociationField(rel) {
+    const target = rel.targetModel;
+    if (rel.kind === 'belongsTo') {
+        return `  @BelongsTo(() => ${target}, { foreignKey: '${rel.foreignKey}', as: '${rel.fieldName}' })\n  declare ${rel.fieldName}: BelongsTo<${target}>;`;
+    }
+    if (rel.kind === 'hasMany') {
+        return `  @HasMany(() => ${target}, { foreignKey: '${rel.foreignKey}', as: '${rel.fieldName}' })\n  declare ${rel.fieldName}: HasMany<${target}>;`;
+    }
+    return `  @HasOne(() => ${target}, { foreignKey: '${rel.foreignKey}', as: '${rel.fieldName}' })\n  declare ${rel.fieldName}: HasOne<${target}>;`;
+}
+/** Generates the full TS source for one model file, including its imports. */
+function generateModelFile(model, allModels, enums, relations) {
+    const enumsByName = new Map(enums.map((e) => [e.name, e.values]));
+    const modelNames = new Set(allModels.map((m) => m.name));
+    const relationsForModel = relations.filter((r) => r.model.name === model.name);
+    const relationFieldNames = new Set(relationsForModel.map((r) => r.fieldName));
+    const foreignKeyColumns = new Set(relations.filter((r) => r.kind === 'belongsTo' && r.model.name === model.name).map((r) => r.foreignKey));
+    const mapAttr = model.blockAttributes.find((a) => a.name === 'map');
+    const tableNameLiteral = mapAttr ? mapAttr.rawArgs.replace(/"/g, '') : model.name;
+    const scalarFieldBlocks = [];
+    for (const field of model.fields) {
+        if (modelNames.has(field.type))
+            continue; // relation field, handled separately
+        if (relationFieldNames.has(field.name))
+            continue;
+        scalarFieldBlocks.push(generateScalarField(field, enumsByName, foreignKeyColumns.has(field.name)));
+    }
+    const associationBlocks = relationsForModel.map(generateAssociationField);
+    const relatedModelImports = Array.from(new Set(relationsForModel.map((r) => r.targetModel).filter((name) => name !== model.name)));
+    const enumTypeAliases = Array.from(new Set(model.fields
+        .map((f) => f.type)
+        .filter((t) => enumsByName.has(t))))
+        .map((enumName) => `type ${enumName} = ${enumsByName.get(enumName).map((v) => `'${v}'`).join(' | ')};`)
+        .join('\n');
+    const needsForeignKeyImport = foreignKeyColumns.size > 0;
+    const needsAssociationImports = relationsForModel.length > 0;
+    const importedDecorators = ['Table', 'Attribute', 'PrimaryKey', 'NotNull', 'Default', 'Unique']
+        .concat(model.fields.some((f) => f.attributes.some((a) => a.name === 'default' && a.rawArgs.trim() === 'autoincrement()')) ? ['AutoIncrement'] : [])
+        .concat(needsAssociationImports ? Array.from(new Set(relationsForModel.map((r) => pascalCase(r.kind)))) : []);
+    const importedTypescriptTypes = ['CreationOptional', 'InferAttributes', 'InferCreationAttributes'].concat(needsForeignKeyImport ? ['ForeignKey'] : []);
+    const lines = [
+        `import { Model, DataTypes, ${importedDecorators.join(', ')} } from 'prorm';`,
+        `import { ${importedTypescriptTypes.join(', ')} } from 'prorm';`,
+        ...relatedModelImports.map((name) => `import { ${name} } from './${name}';`),
+        '',
+        enumTypeAliases,
+        enumTypeAliases ? '' : null,
+        `@Table({ tableName: '${tableNameLiteral}', timestamps: false })`,
+        `export class ${model.name} extends Model<InferAttributes<${model.name}>, InferCreationAttributes<${model.name}>> {`,
+        scalarFieldBlocks.join('\n\n'),
+        associationBlocks.length ? '\n' + associationBlocks.join('\n\n') : null,
+        '}',
+        '',
+    ].filter((l) => l !== null);
+    return lines.join('\n');
+}
+/** Generates a barrel file that imports every model and calls `prorm.addModels([...])`, matching the registration pattern real prorm projects use (see docs-next/docs/example/basic/user-model.ts). */
+function generateModelsIndex(models) {
+    const imports = models.map((m) => `import { ${m.name} } from './${m.name}';`).join('\n');
+    const names = models.map((m) => m.name).join(', ');
+    return [
+        imports,
+        '',
+        `export { ${names} };`,
+        '',
+        '/** Call this once after creating your Prorm instance, before syncing/querying. */',
+        'export function registerModels(prorm: { addModels: (models: unknown[]) => void }): void {',
+        `  prorm.addModels([${names}]);`,
+        '}',
+        '',
+    ].join('\n');
+}

package/dist/prisma-migrate/relations.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * Resolves Prisma relation fields (fields whose type names another model)
+ * into prorm association descriptors. Prisma always represents a relation
+ * as a *pair* of fields, one on each model — this module's job is to find
+ * each pair and figure out which side owns the foreign key.
+ *
+ * Scope: only explicit one-to-many / one-to-one relations (one side has
+ * `@relation(fields: [...], references: [...])`) are supported. Prisma's
+ * *implicit* many-to-many relations (both sides are plain `Model[]` with no
+ * `@relation` attribute and no join model) have no owning-FK side to
+ * resolve — Prisma auto-generates a hidden join table for these with a
+ * naming/column scheme this tool doesn't attempt to reverse-engineer.
+ * `resolveRelations` throws a clear error naming the two models instead of
+ * guessing at that join table's shape.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRelations = resolveRelations;
+/** Parses `@relation(...)`'s raw argument text: an optional leading string (the relation name) plus `fields: [...]`/`references: [...]` named args. */
+function parseRelationArgs(rawArgs) {
+    const result = {};
+    const nameMatch = rawArgs.match(/^\s*"([^"]*)"/);
+    if (nameMatch)
+        result.name = nameMatch[1];
+    const fieldsMatch = rawArgs.match(/fields\s*:\s*\[([^\]]*)\]/);
+    if (fieldsMatch) {
+        result.fields = fieldsMatch[1]
+            .split(',')
+            .map((s) => s.trim())
+            .filter(Boolean);
+    }
+    const referencesMatch = rawArgs.match(/references\s*:\s*\[([^\]]*)\]/);
+    if (referencesMatch) {
+        result.references = referencesMatch[1]
+            .split(',')
+            .map((s) => s.trim())
+            .filter(Boolean);
+    }
+    const namedNameMatch = rawArgs.match(/(?:^|,)\s*name\s*:\s*"([^"]*)"/);
+    if (namedNameMatch)
+        result.name = namedNameMatch[1];
+    return result;
+}
+/** Unordered pair key so `(A, B)` and `(B, A)` land in the same bucket. */
+function pairKey(a, b, name) {
+    const [x, y] = [a, b].sort();
+    return name ? `named:${name}` : `pair:${x}:${y}`;
+}
+function resolveRelations(models, modelNames) {
+    const relations = [];
+    const buckets = new Map();
+    for (const model of models) {
+        for (const field of model.fields) {
+            if (!modelNames.has(field.type))
+                continue; // scalar/enum field, not a relation
+            const relationAttr = field.attributes.find((a) => a.name === 'relation');
+            const args = relationAttr ? parseRelationArgs(relationAttr.rawArgs) : {};
+            const key = pairKey(model.name, field.type, args.name);
+            if (!buckets.has(key))
+                buckets.set(key, []);
+            buckets.get(key).push({ model, field, args });
+        }
+    }
+    for (const [key, sides] of buckets) {
+        if (sides.length !== 2) {
+            // A one-sided relation field (no matching inverse) or an implicit
+            // many-to-many bucket that didn't pair up 1:1 falls here too.
+            throw new Error(`prisma-migrate: could not resolve relation "${key}" — expected exactly 2 matching relation fields (one on each model), found ${sides.length}. ` +
+                `Implicit many-to-many relations (both sides declared as plain arrays with no @relation attribute) aren't supported — add an explicit join model instead.`);
+        }
+        const owningSide = sides.find((s) => s.args.fields && s.args.references);
+        const inverseSide = sides.find((s) => s !== owningSide);
+        if (!owningSide || !inverseSide) {
+            const bothArrays = sides.every((s) => s.field.isArray);
+            const hint = bothArrays
+                ? ' 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.'
+                : ' Add @relation(fields: [...], references: [...]) to whichever side owns the foreign key column.';
+            throw new Error(`prisma-migrate: relation between "${sides[0].model.name}" and "${sides[1].model.name}" has no side declaring @relation(fields: [...], references: [...]) — can't determine which side owns the foreign key.${hint}`);
+        }
+        if (owningSide.args.fields.length !== 1) {
+            throw new Error(`prisma-migrate: composite foreign keys aren't supported (relation on "${owningSide.model.name}.${owningSide.field.name}" references ${owningSide.args.fields.length} columns).`);
+        }
+        const foreignKey = owningSide.args.fields[0];
+        relations.push({
+            kind: 'belongsTo',
+            model: owningSide.model,
+            fieldName: owningSide.field.name,
+            targetModel: owningSide.field.type,
+            foreignKey,
+        });
+        relations.push({
+            kind: inverseSide.field.isArray ? 'hasMany' : 'hasOne',
+            model: inverseSide.model,
+            fieldName: inverseSide.field.name,
+            targetModel: inverseSide.field.type,
+            foreignKey,
+        });
+    }
+    return relations;
+}

package/dist/prisma-migrate/schema-parser.js

@@ -0,0 +1,167 @@
+"use strict";
+/**
+ * Minimal hand-rolled parser for Prisma's `schema.prisma` grammar, scoped to
+ * exactly what `model-generator.ts`/`migration-generator.ts` need: `model`
+ * and `enum` blocks, field declarations, and field-level (`@`) / block-level
+ * (`@@`) attributes. `datasource`/`generator` blocks are parsed only far
+ * enough to skip over them — this tool doesn't need a live DB connection or
+ * codegen config, only the schema shape.
+ *
+ * This is not a full Prisma schema validator: it assumes the input already
+ * parses with Prisma's own `prisma validate` (this tool is meant to run
+ * against a schema the user is already using with Prisma). Malformed input
+ * produces a best-effort partial result rather than a precise parse error.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePrismaSchema = parsePrismaSchema;
+/** Strips `//` line comments and `/* *\/` block comments without touching string literals that might contain `//`. */
+function stripComments(source) {
+    let result = '';
+    let i = 0;
+    let inString = false;
+    while (i < source.length) {
+        const ch = source[i];
+        const next = source[i + 1];
+        if (inString) {
+            result += ch;
+            if (ch === '\\') {
+                result += next ?? '';
+                i += 2;
+                continue;
+            }
+            if (ch === '"')
+                inString = false;
+            i++;
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            result += ch;
+            i++;
+            continue;
+        }
+        if (ch === '/' && next === '/') {
+            while (i < source.length && source[i] !== '\n')
+                i++;
+            continue;
+        }
+        if (ch === '/' && next === '*') {
+            i += 2;
+            while (i < source.length && !(source[i] === '*' && source[i + 1] === '/'))
+                i++;
+            i += 2;
+            continue;
+        }
+        result += ch;
+        i++;
+    }
+    return result;
+}
+/** Extracts the body of every top-level `<keyword> <Name> { ... }` block (brace-depth aware, so nested `{}` in attribute args don't terminate the block early). */
+function extractBlocks(source, keyword) {
+    const blocks = [];
+    const headerRe = new RegExp(`\\b${keyword}\\s+(\\w+)\\s*\\{`, 'g');
+    let match;
+    while ((match = headerRe.exec(source))) {
+        const name = match[1];
+        const start = match.index + match[0].length;
+        let depth = 1;
+        let end = start;
+        while (end < source.length && depth > 0) {
+            if (source[end] === '{')
+                depth++;
+            else if (source[end] === '}')
+                depth--;
+            end++;
+        }
+        blocks.push({ name, body: source.slice(start, end - 1) });
+        headerRe.lastIndex = end;
+    }
+    return blocks;
+}
+/**
+ * Splits an attribute-chain like `@id @default(autoincrement()) @map("user_id")`
+ * into individual attributes, correctly treating a `@@`-prefixed attribute as
+ * one attribute (not two `@` tokens) and respecting parens so a `)` inside a
+ * string/nested call doesn't end the argument list early.
+ */
+function parseAttributes(text) {
+    const attributes = [];
+    let i = 0;
+    while (i < text.length) {
+        if (text[i] !== '@') {
+            i++;
+            continue;
+        }
+        let start = i;
+        i++;
+        if (text[i] === '@')
+            i++; // block-level @@attr
+        let name = '';
+        while (i < text.length && /[\w.]/.test(text[i])) {
+            name += text[i];
+            i++;
+        }
+        let rawArgs = '';
+        if (text[i] === '(') {
+            let depth = 1;
+            i++;
+            const argStart = i;
+            while (i < text.length && depth > 0) {
+                if (text[i] === '(')
+                    depth++;
+                else if (text[i] === ')')
+                    depth--;
+                if (depth > 0)
+                    i++;
+            }
+            rawArgs = text.slice(argStart, i);
+            i++; // consume closing ')'
+        }
+        attributes.push({ name, rawArgs });
+        void start;
+    }
+    return attributes;
+}
+function parseModelBody(body) {
+    const fields = [];
+    const blockAttributes = [];
+    for (const rawLine of body.split('\n')) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        if (line.startsWith('@@')) {
+            blockAttributes.push(...parseAttributes(line));
+            continue;
+        }
+        // `name Type[]? @attr1 @attr2(...)` — type token ends at the first
+        // whitespace or `@`; everything after the type is attributes.
+        const fieldMatch = line.match(/^(\w+)\s+(\w+)(\[\])?(\?)?\s*(.*)$/);
+        if (!fieldMatch)
+            continue; // skip stray tokens (e.g. a lone closing brace artifact)
+        const [, name, type, arrayMark, optionalMark, rest] = fieldMatch;
+        fields.push({
+            name,
+            type,
+            isArray: Boolean(arrayMark),
+            isOptional: Boolean(optionalMark),
+            attributes: parseAttributes(rest),
+        });
+    }
+    return { fields, blockAttributes };
+}
+function parsePrismaSchema(source) {
+    const cleaned = stripComments(source);
+    const models = extractBlocks(cleaned, 'model').map(({ name, body }) => {
+        const { fields, blockAttributes } = parseModelBody(body);
+        return { name, fields, blockAttributes };
+    });
+    const enums = extractBlocks(cleaned, 'enum').map(({ name, body }) => ({
+        name,
+        values: body
+            .split('\n')
+            .map((l) => l.trim().split(/\s/)[0])
+            .filter((v) => v && !v.startsWith('@')),
+    }));
+    return { models, enums };
+}

package/dist/prisma-migrate/type-mapper.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCALAR_TYPE_MAP = void 0;
+exports.mapPrismaType = mapPrismaType;
+/**
+ * Maps Prisma scalar types to prorm `DataTypes` expressions. Enum types
+ * aren't in this table — callers check `enumNames` first and build
+ * `DataTypes.ENUM(...)` from the enum's own values instead, since the
+ * mapping depends on data only the caller has (the parsed `PrismaEnum`).
+ */
+const SCALAR_TYPE_MAP = {
+    String: 'DataTypes.STRING(191)',
+    Int: 'DataTypes.INTEGER()',
+    BigInt: 'DataTypes.BIGINT()',
+    Float: 'DataTypes.FLOAT()',
+    Decimal: 'DataTypes.DECIMAL(65, 30)',
+    Boolean: 'DataTypes.BOOLEAN()',
+    DateTime: 'DataTypes.DATE()',
+    Json: 'DataTypes.JSON()',
+    Bytes: 'DataTypes.BLOB()',
+};
+exports.SCALAR_TYPE_MAP = SCALAR_TYPE_MAP;
+/**
+ * @param type - A Prisma scalar type name (`String`, `Int`, ...) or an enum name from the same schema.
+ * @param enumsByName - Every enum declared in the schema, keyed by name, so an enum reference can be expanded to its values.
+ * @throws if `type` is neither a known Prisma scalar nor a declared enum (e.g. an unresolved relation type reached this function by mistake, or a Prisma type this tool doesn't yet map — `Unsupported` rather than a guess, matching this codebase's convention of refusing to invent unverified SQL/type behavior).
+ */
+function mapPrismaType(type, enumsByName) {
+    const enumValues = enumsByName.get(type);
+    if (enumValues) {
+        const valuesLiteral = enumValues.map((v) => `'${v.replace(/'/g, "\\'")}'`).join(', ');
+        return { dataTypeExpr: `DataTypes.ENUM(${valuesLiteral})`, isEnum: true };
+    }
+    const mapped = SCALAR_TYPE_MAP[type];
+    if (!mapped) {
+        throw new Error(`prisma-migrate: unsupported Prisma type "${type}" — no known prorm DataTypes equivalent, and it isn't one of this schema's enums. ` +
+            `Supported scalars: ${Object.keys(SCALAR_TYPE_MAP).join(', ')}.`);
+    }
+    return { dataTypeExpr: mapped, isEnum: false };
+}