ts-prorm-orm 1.1.0 → 1.2.1

package/dist/operators.js

@@ -77,6 +77,7 @@ exports.jsonPathExists = jsonPathExists;
 exports.jsonPathQuery = jsonPathQuery;
 exports.fn = fn;
 exports.col = col;
+exports.expandLiteralBindings = expandLiteralBindings;
 exports.literal = literal;
 exports.literalExpr = literalExpr;
 exports.isFnExpression = isFnExpression;
@@ -2251,6 +2252,49 @@ function col(colName) {
         col: colName,
     };
 }
+/**
+ * Substitute a literal expression's bindings into its `?` placeholders.
+ *
+ * Dialects call this with their own `escape` so values are quoted according to
+ * the target database's rules. Exported so every dialect shares one
+ * implementation rather than re-deriving the placeholder scan.
+ */
+function expandLiteralBindings(expr, escape) {
+    const bindings = expr.bindings;
+    if (!bindings || bindings.length === 0)
+        return expr.sql;
+    let index = 0;
+    // Skip `?` inside single-quoted string literals so a question mark in text
+    // isn't treated as a placeholder.
+    let inString = false;
+    let out = '';
+    for (let i = 0; i < expr.sql.length; i++) {
+        const ch = expr.sql[i];
+        if (ch === "'") {
+            // Doubled '' is an escaped quote inside a string, not a terminator.
+            if (inString && expr.sql[i + 1] === "'") {
+                out += "''";
+                i++;
+                continue;
+            }
+            inString = !inString;
+            out += ch;
+            continue;
+        }
+        if (ch === '?' && !inString) {
+            if (index >= bindings.length) {
+                throw new Error(`literalExpr: SQL has more ? placeholders than the ${bindings.length} binding(s) provided`);
+            }
+            out += escape(bindings[index++]);
+            continue;
+        }
+        out += ch;
+    }
+    if (index < bindings.length) {
+        throw new Error(`literalExpr: ${bindings.length} binding(s) provided but SQL has only ${index} ? placeholder(s)`);
+    }
+    return out;
+}
 /**
  * Create a literal SQL expression (inserted as-is into the query)
  * Returns { $literal: value } format for raw SQL expressions
@@ -2291,10 +2335,11 @@ function literal(value) {
  * literalExpr('1 + 1')    // -> { __type: 'literal', sql: '1 + 1' }
  * ```
  */
-function literalExpr(sql) {
+function literalExpr(sql, bindings) {
     return {
         __type: 'literal',
         sql,
+        ...(bindings ? { bindings } : {}),
     };
 }
 /**

package/dist/prisma-migrate/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 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.
+ */
+export { parsePrismaSchema } from './schema-parser';
+export type { PrismaSchema, PrismaModel, PrismaEnum, PrismaField } from './schema-parser';
+export { resolveRelations } from './relations';
+export type { PrormRelation } from './relations';
+export interface ConversionResult {
+    /** One generated model file per Prisma `model` block, keyed by class/file name (without extension). */
+    models: {
+        name: string;
+        source: string;
+    }[];
+    /** Barrel file that imports every model and exposes `registerModels(prorm)`. */
+    modelsIndex: string;
+    /** Single "initial schema" migration covering every table and relation. */
+    migration: string;
+}
+/**
+ * @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.
+ */
+export declare function convertPrismaSchema(schemaSource: string): ConversionResult;

package/dist/prisma-migrate/migration-generator.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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.
+ */
+import { PrismaModel, PrismaEnum } from './schema-parser';
+import { PrormRelation } from './relations';
+/**
+ * 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.
+ */
+export declare function generateInitialMigration(models: PrismaModel[], enums: PrismaEnum[], relations: PrormRelation[]): string;

package/dist/prisma-migrate/model-generator.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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.
+ */
+import { PrismaModel, PrismaEnum } from './schema-parser';
+import { PrormRelation } from './relations';
+/** Generates the full TS source for one model file, including its imports. */
+export declare function generateModelFile(model: PrismaModel, allModels: PrismaModel[], enums: PrismaEnum[], relations: PrormRelation[]): string;
+/** 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). */
+export declare function generateModelsIndex(models: PrismaModel[]): string;

package/dist/prisma-migrate/relations.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 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.
+ */
+import { PrismaModel } from './schema-parser';
+export interface PrormRelation {
+    kind: 'belongsTo' | 'hasMany' | 'hasOne';
+    /** Model the decorator is attached to. */
+    model: PrismaModel;
+    /** Property name for the association (the Prisma relation field's own name). */
+    fieldName: string;
+    /** Name of the related model. */
+    targetModel: string;
+    /** Foreign key column name (present on the `belongsTo` side's model, and mirrored here on its `hasMany`/`hasOne` inverse for `foreignKey` option generation). */
+    foreignKey: string;
+}
+export declare function resolveRelations(models: PrismaModel[], modelNames: Set<string>): PrormRelation[];

package/dist/prisma-migrate/schema-parser.d.ts

@@ -0,0 +1,42 @@
+/**
+ * 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.
+ */
+export interface PrismaAttribute {
+    /** Attribute name without the leading `@`/`@@`, e.g. `"id"`, `"relation"`, `"map"`. */
+    name: string;
+    /** Raw, unparsed argument list inside the attribute's parentheses (empty string if there were none). Left raw because argument syntax varies per attribute (named args, function calls like `autoincrement()`, array literals). */
+    rawArgs: string;
+}
+export interface PrismaField {
+    name: string;
+    /** Prisma scalar type name (`String`, `Int`, ...) or another model/enum name for relations, with `[]`/`?` already stripped. */
+    type: string;
+    isArray: boolean;
+    isOptional: boolean;
+    attributes: PrismaAttribute[];
+}
+export interface PrismaModel {
+    name: string;
+    fields: PrismaField[];
+    /** Block-level (`@@...`) attributes: `@@id`, `@@unique`, `@@index`, `@@map`. */
+    blockAttributes: PrismaAttribute[];
+}
+export interface PrismaEnum {
+    name: string;
+    values: string[];
+}
+export interface PrismaSchema {
+    models: PrismaModel[];
+    enums: PrismaEnum[];
+}
+export declare function parsePrismaSchema(source: string): PrismaSchema;

package/dist/prisma-migrate/type-mapper.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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`).
+ */
+declare const SCALAR_TYPE_MAP: Record<string, string>;
+export interface TypeMappingResult {
+    /** A prorm `DataTypes.X(...)` expression as source text, ready to splice into a generated `@Attribute(...)` call. */
+    dataTypeExpr: string;
+    /** True if `type` refers to one of the schema's own `enum` blocks rather than a Prisma scalar. */
+    isEnum: boolean;
+}
+/**
+ * @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).
+ */
+export declare function mapPrismaType(type: string, enumsByName: Map<string, string[]>): TypeMappingResult;
+export { SCALAR_TYPE_MAP };