turbine-orm 0.40.1 → 0.41.0

package/dist/generate.d.ts

@@ -8,7 +8,7 @@
  *
  * Output goes to the specified directory (default: ./generated/turbine/).
  */
-import { type SchemaMetadata } from './schema.js';
+import { type PrismaCompatMap, type SchemaMetadata } from './schema.js';
 export interface GenerateOptions {
     /** The introspected schema to generate from */
     schema: SchemaMetadata;
@@ -30,16 +30,85 @@ export interface GenerateOptions {
      * diffs. Default: `false` (timestamp included, unchanged behavior).
      */
     noTimestamp?: boolean;
+    /**
+     * Which extension the generated `index.ts` uses on its sibling import
+     * specifiers (`./types`, `./metadata`). F3.
+     *
+     *   - `'js'`: always `./types.js` (required by NodeNext `tsc` and by
+     *     tsc-compiled ESM run on Node; the pre-0.41 behavior).
+     *   - `'none'`: always `./types` (correct for bundlers / `moduleResolution
+     *     bundler | node10`: webpack, Next.js/SWC, Vite/esbuild).
+     *   - `'auto'` (default): walk up from `outDir` to the nearest `tsconfig.json`
+     *     (extends chains are NOT followed) and emit `'.js'` when its `module` /
+     *     `moduleResolution` is `node16`/`nodenext`, `''` when both are present and
+     *     neither is, and fall back to `'.js'` when the tsconfig is missing,
+     *     unparseable, or ambiguous (so NodeNext consumers can never regress).
+     */
+    importExtension?: 'js' | 'none' | 'auto';
+    /**
+     * Rewrite generated column FIELD names to the raw database column names
+     * (snake_case) instead of camelCase (F4). Opt-in; when unset the output is
+     * byte-identical to before. Implemented as the pure generate-time
+     * {@link withDbFieldNames} transform (identity `columnMap`/`reverseColumnMap`,
+     * zero runtime changes). Relation names, table accessors, and entity type
+     * names are unaffected.
+     */
+    keepColumnNames?: boolean;
 }
 /** Per-file generator options (subset of {@link GenerateOptions} the emitters need). */
 export interface GenerateFileOptions {
     /** Omit the `Generated at:` header line for reproducible output. */
     noTimestamp?: boolean;
+    /**
+     * Resolved sibling-import extension for `generateIndex` (`'.js'` or `''`).
+     * Defaults to `'.js'` when unset so direct callers stay byte-stable.
+     */
+    importExt?: string;
+    /** Human-readable resolved import mode, recorded as a comment in `index.ts`. */
+    importMode?: string;
 }
 export declare function generate(options: GenerateOptions): {
     outDir: string;
     files: string[];
 };
+/**
+ * Resolve the requested {@link GenerateOptions.importExtension} to the concrete
+ * extension string used on `index.ts`'s sibling imports plus a human-readable
+ * mode label for the generated comment.
+ *
+ *   - `'js'`   → `.js`
+ *   - `'none'` → `''`
+ *   - `'auto'` → tsconfig-driven ({@link detectTsconfigExtension}); falls back
+ *     to `.js` (the pre-0.41 default) when detection is uncertain, so NodeNext
+ *     consumers can never regress.
+ */
+export declare function resolveImportExtension(outDir: string, requested: 'js' | 'none' | 'auto'): {
+    ext: string;
+    mode: string;
+};
+/**
+ * Walk up from `startDir` to the nearest `tsconfig.json` and classify its module
+ * resolution. Does NOT follow `extends` chains (a monorepo whose base config
+ * sets `moduleResolution` needs the explicit flag). Returns:
+ *   - `'js'`: `module`/`moduleResolution` is `node16`/`nodenext`;
+ *   - `'none'`: both fields present and neither is node16/nodenext (bundler,
+ *     node, node10, classic, esnext, commonjs, preserve);
+ *   - `null`: no tsconfig found, unparseable, or the fields are absent
+ *     (possibly hidden behind `extends`) → caller falls back to `.js`.
+ */
+export declare function detectTsconfigExtension(startDir: string): 'js' | 'none' | null;
+/**
+ * Classify a tsconfig's `compilerOptions.module` / `moduleResolution` (see
+ * {@link detectTsconfigExtension}). Tolerant of `//` and block comments and
+ * trailing commas (real-world tsconfigs use JSONC).
+ */
+export declare function classifyTsconfig(text: string): 'js' | 'none' | null;
+/**
+ * Strip `//` line comments and block comments from JSONC text, leaving anything
+ * inside a double-quoted string untouched. Trailing commas are then removed so
+ * `JSON.parse` accepts the result.
+ */
+export declare function stripJsonComments(text: string): string;
 /**
  * Generate the contents of `types.ts` (entity interfaces, *Create / *Update,
  * and *Relations brand-field interfaces). Exported so tests can pin the
@@ -56,3 +125,13 @@ export declare function generateTypes(schema: SchemaMetadata, options?: Generate
 export declare function generateZod(schema: SchemaMetadata, options?: GenerateFileOptions): string;
 export declare function generateMetadata(schema: SchemaMetadata, options?: GenerateFileOptions): string;
 export declare function generateIndex(schema: SchemaMetadata, options?: GenerateFileOptions): string;
+/**
+ * Serialize a resolved {@link PrismaCompatMap} into a `prisma-map.ts` module
+ * that exports `export const PRISMA_MAP: PrismaCompatMap = {...}`. Written next
+ * to the generated client by `turbine migrate-from-prisma`; consumed later by
+ * the phase-2 `turbine-orm/prisma-compat` runtime adapter.
+ *
+ * Deterministic: uses the same reproducible header as the other emitters, so a
+ * stable input regenerates byte-identical output under `noTimestamp`.
+ */
+export declare function generatePrismaMap(map: PrismaCompatMap, options?: GenerateFileOptions): string;

package/dist/generate.js

@@ -8,9 +8,9 @@
  *
  * Output goes to the specified directory (default: ./generated/turbine/).
  */
-import { mkdirSync, writeFileSync } from 'node:fs';
-import { join, relative, resolve } from 'node:path';
-import { pgTypeToTs, singularize, snakeToPascal, } from './schema.js';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative, resolve } from 'node:path';
+import { pgTypeToTs, singularize, snakeToPascal, withDbFieldNames, } from './schema.js';
 /** Get the TypeScript type name for a table (singularized PascalCase) */
 function entityName(tableName) {
     return snakeToPascal(singularize(tableName));
@@ -49,29 +49,177 @@ export function generate(options) {
         throw new Error(`Output directory must be within the project root. Got: ${outDir}`);
     }
     mkdirSync(outDir, { recursive: true });
+    // F4: keep raw DB column names as field names (opt-in). Pure transform: when
+    // the flag is off `withDbFieldNames` is never called and output is unchanged.
+    const schema = options.keepColumnNames ? withDbFieldNames(options.schema) : options.schema;
+    // F3: resolve which extension sibling imports get in index.ts.
+    const { ext: importExt, mode: importMode } = resolveImportExtension(outDir, options.importExtension ?? 'auto');
     const files = [];
-    const fileOptions = { noTimestamp: options.noTimestamp };
+    const fileOptions = { noTimestamp: options.noTimestamp, importExt, importMode };
     // Generate types.ts
-    const typesContent = generateTypes(options.schema, fileOptions);
+    const typesContent = generateTypes(schema, fileOptions);
     writeFileSync(join(outDir, 'types.ts'), typesContent, 'utf-8');
     files.push('types.ts');
     // Generate metadata.ts
-    const metadataContent = generateMetadata(options.schema, fileOptions);
+    const metadataContent = generateMetadata(schema, fileOptions);
     writeFileSync(join(outDir, 'metadata.ts'), metadataContent, 'utf-8');
     files.push('metadata.ts');
     // Generate index.ts (configured client)
-    const indexContent = generateIndex(options.schema, fileOptions);
+    const indexContent = generateIndex(schema, fileOptions);
     writeFileSync(join(outDir, 'index.ts'), indexContent, 'utf-8');
     files.push('index.ts');
     // Generate zod.ts (optional — --zod flag)
     if (options.zod) {
-        const zodContent = generateZod(options.schema, fileOptions);
+        const zodContent = generateZod(schema, fileOptions);
         writeFileSync(join(outDir, 'zod.ts'), zodContent, 'utf-8');
         files.push('zod.ts');
     }
     return { outDir, files };
 }
 // ---------------------------------------------------------------------------
+// Import-extension resolution (F3)
+// ---------------------------------------------------------------------------
+/**
+ * Resolve the requested {@link GenerateOptions.importExtension} to the concrete
+ * extension string used on `index.ts`'s sibling imports plus a human-readable
+ * mode label for the generated comment.
+ *
+ *   - `'js'`   → `.js`
+ *   - `'none'` → `''`
+ *   - `'auto'` → tsconfig-driven ({@link detectTsconfigExtension}); falls back
+ *     to `.js` (the pre-0.41 default) when detection is uncertain, so NodeNext
+ *     consumers can never regress.
+ */
+export function resolveImportExtension(outDir, requested) {
+    if (requested === 'js')
+        return { ext: '.js', mode: 'js' };
+    if (requested === 'none')
+        return { ext: '', mode: 'none' };
+    const detected = detectTsconfigExtension(resolve(outDir));
+    if (detected === 'js')
+        return { ext: '.js', mode: 'auto (nodenext → .js)' };
+    if (detected === 'none')
+        return { ext: '', mode: 'auto (bundler → no extension)' };
+    return { ext: '.js', mode: 'auto (fallback → .js)' };
+}
+/**
+ * Walk up from `startDir` to the nearest `tsconfig.json` and classify its module
+ * resolution. Does NOT follow `extends` chains (a monorepo whose base config
+ * sets `moduleResolution` needs the explicit flag). Returns:
+ *   - `'js'`: `module`/`moduleResolution` is `node16`/`nodenext`;
+ *   - `'none'`: both fields present and neither is node16/nodenext (bundler,
+ *     node, node10, classic, esnext, commonjs, preserve);
+ *   - `null`: no tsconfig found, unparseable, or the fields are absent
+ *     (possibly hidden behind `extends`) → caller falls back to `.js`.
+ */
+export function detectTsconfigExtension(startDir) {
+    let dir = startDir;
+    for (;;) {
+        const candidate = join(dir, 'tsconfig.json');
+        if (existsSync(candidate)) {
+            try {
+                return classifyTsconfig(readFileSync(candidate, 'utf-8'));
+            }
+            catch {
+                return null;
+            }
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null; // reached the filesystem root
+        dir = parent;
+    }
+}
+/**
+ * Classify a tsconfig's `compilerOptions.module` / `moduleResolution` (see
+ * {@link detectTsconfigExtension}). Tolerant of `//` and block comments and
+ * trailing commas (real-world tsconfigs use JSONC).
+ */
+export function classifyTsconfig(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stripJsonComments(text));
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed !== 'object' || parsed === null)
+        return null;
+    const co = parsed.compilerOptions;
+    if (typeof co !== 'object' || co === null)
+        return null;
+    const opts = co;
+    const mod = typeof opts.module === 'string' ? opts.module.toLowerCase() : undefined;
+    const modRes = typeof opts.moduleResolution === 'string' ? opts.moduleResolution.toLowerCase() : undefined;
+    const isNodeNext = (v) => v === 'node16' || v === 'nodenext';
+    if (isNodeNext(mod) || isNodeNext(modRes))
+        return 'js';
+    if (mod !== undefined && modRes !== undefined)
+        return 'none';
+    return null;
+}
+/**
+ * Strip `//` line comments and block comments from JSONC text, leaving anything
+ * inside a double-quoted string untouched. Trailing commas are then removed so
+ * `JSON.parse` accepts the result.
+ */
+export function stripJsonComments(text) {
+    let out = '';
+    let inString = false;
+    let inLine = false;
+    let inBlock = false;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        const next = text[i + 1];
+        if (inLine) {
+            if (ch === '\n') {
+                inLine = false;
+                out += ch;
+            }
+            continue;
+        }
+        if (inBlock) {
+            if (ch === '*' && next === '/') {
+                inBlock = false;
+                i++;
+            }
+            continue;
+        }
+        if (inString) {
+            out += ch;
+            if (ch === '\\') {
+                // Preserve the escaped character verbatim.
+                if (next !== undefined) {
+                    out += next;
+                    i++;
+                }
+            }
+            else if (ch === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            out += ch;
+            continue;
+        }
+        if (ch === '/' && next === '/') {
+            inLine = true;
+            i++;
+            continue;
+        }
+        if (ch === '/' && next === '*') {
+            inBlock = true;
+            i++;
+            continue;
+        }
+        out += ch;
+    }
+    // Drop trailing commas before } or ].
+    return out.replace(/,(\s*[}\]])/g, '$1');
+}
+// ---------------------------------------------------------------------------
 // types.ts generator
 // ---------------------------------------------------------------------------
 function generatedFileHeader(options) {
@@ -167,7 +315,7 @@ export function generateTypes(schema, options) {
             const piiNote = col.pii ? ' (PII: absent unless selected or includePii)' : '';
             const optional = col.pii ? '?' : '';
             lines.push(`  /** Column: ${col.name}, ${col.pgType}${pkNote}${nullNote}${piiNote} */`);
-            lines.push(`  ${col.field}${optional}: ${columnTsType(col, schema.enums)};`);
+            lines.push(`  ${quoteIfNeeded(col.field)}${optional}: ${columnTsType(col, schema.enums)};`);
         }
         lines.push('}');
         lines.push('');
@@ -185,10 +333,10 @@ export function generateTypes(schema, options) {
             if (isOptional) {
                 const reason = isPk ? 'auto-generated' : col.hasDefault ? 'has default' : 'nullable';
                 lines.push(`  /** Optional: ${reason} */`);
-                lines.push(`  ${col.field}?: ${columnTsType(col, schema.enums)};`);
+                lines.push(`  ${quoteIfNeeded(col.field)}?: ${columnTsType(col, schema.enums)};`);
             }
             else {
-                lines.push(`  ${col.field}: ${columnTsType(col, schema.enums)};`);
+                lines.push(`  ${quoteIfNeeded(col.field)}: ${columnTsType(col, schema.enums)};`);
             }
         }
         lines.push('};');
@@ -200,7 +348,7 @@ export function generateTypes(schema, options) {
         lines.push(`/** Input type for updating a row in \`${table.name}\` */`);
         lines.push(`export type ${typeName}Update = {`);
         for (const col of nonPkCols) {
-            lines.push(`  ${col.field}?: ${updateFieldType(columnTsType(col, schema.enums))};`);
+            lines.push(`  ${quoteIfNeeded(col.field)}?: ${updateFieldType(columnTsType(col, schema.enums))};`);
         }
         lines.push('};');
         lines.push('');
@@ -269,15 +417,54 @@ export function generateTypes(schema, options) {
             }
         }
         if (uniqueSets.length > 0) {
-            const branches = uniqueSets.map((cols) => {
+            const memberType = (colName) => {
+                const col = table.columns.find((c) => c.name === colName);
+                return { field: col?.field ?? colName, tsType: col?.tsType ?? 'unknown' };
+            };
+            // Flat branches: one object per unique constraint carrying its columns.
+            const flatBranches = uniqueSets.map((cols) => {
                 const fields = cols.map((colName) => {
-                    const col = table.columns.find((c) => c.name === colName);
-                    const field = col?.field ?? colName;
-                    const tsType = col?.tsType ?? 'unknown';
-                    return `${field}: ${tsType}`;
+                    const m = memberType(colName);
+                    return `${quoteIfNeeded(m.field)}: ${m.tsType}`;
                 });
                 return `{ ${fields.join('; ')} }`;
             });
+            // Prisma-style compound-unique SELECTOR branches: a synthetic key
+            // (`orgId_userId`) whose value holds the member columns, emitted for every
+            // COMPOSITE unique (PK, composite UNIQUE constraint, or composite UNIQUE
+            // index). Runtime expansion lives in query/compound-unique.ts.
+            const compoundSeen = new Set();
+            const compoundSets = [];
+            const addCompound = (cols) => {
+                if (cols.length < 2)
+                    return;
+                const key = cols.join(',');
+                if (compoundSeen.has(key))
+                    return;
+                compoundSeen.add(key);
+                compoundSets.push(cols);
+            };
+            addCompound(table.primaryKey);
+            for (const uc of table.uniqueColumns)
+                addCompound(uc);
+            for (const idx of table.indexes) {
+                if (idx.unique && !idx.docPath)
+                    addCompound(idx.columns);
+            }
+            const selectorEntries = compoundSets.map((cols) => {
+                const members = cols.map(memberType);
+                return {
+                    selectorName: members.map((m) => m.field).join('_'),
+                    memberType: `{ ${members.map((m) => `${quoteIfNeeded(m.field)}: ${m.tsType}`).join('; ')} }`,
+                };
+            });
+            // Named helper type for annotating a compound selector by hand (Prisma parity).
+            if (selectorEntries.length > 0) {
+                const cuFields = selectorEntries.map((e) => `${e.selectorName}: ${e.memberType}`);
+                lines.push(`export type ${typeName}CompoundUniques = { ${cuFields.join('; ')} };`);
+            }
+            const selectorBranches = selectorEntries.map((e) => `{ ${e.selectorName}: ${e.memberType} }`);
+            const branches = [...flatBranches, ...selectorBranches];
             lines.push(`export type ${typeName}WhereUnique = ${branches.join(' | ')};`);
             lines.push('');
         }
@@ -407,7 +594,7 @@ export function generateZod(schema, options) {
             let expr = zodBaseType(col, schema.enums);
             if (col.nullable)
                 expr += '.nullable()';
-            lines.push(`  ${col.field}: ${expr},`);
+            lines.push(`  ${quoteIfNeeded(col.field)}: ${expr},`);
         }
         lines.push('});');
         lines.push('');
@@ -424,7 +611,7 @@ export function generateZod(schema, options) {
                 expr += '.nullable()';
             if (col.hasDefault || col.nullable || isPk)
                 expr += '.optional()';
-            lines.push(`  ${col.field}: ${expr},`);
+            lines.push(`  ${quoteIfNeeded(col.field)}: ${expr},`);
         }
         lines.push('});');
         lines.push('');
@@ -440,7 +627,7 @@ export function generateZod(schema, options) {
             if (col.nullable)
                 expr += '.nullable()';
             expr += '.optional()';
-            lines.push(`  ${col.field}: ${expr},`);
+            lines.push(`  ${quoteIfNeeded(col.field)}: ${expr},`);
         }
         lines.push('});');
         lines.push('');
@@ -470,7 +657,7 @@ export function generateMetadata(schema, options) {
         // columnMap
         lines.push('      columnMap: {');
         for (const [field, col] of Object.entries(table.columnMap)) {
-            lines.push(`        ${field}: '${escSQ(col)}',`);
+            lines.push(`        ${quoteIfNeeded(field)}: '${escSQ(col)}',`);
         }
         lines.push('      },');
         // reverseColumnMap
@@ -570,11 +757,17 @@ export function generateIndex(schema, options) {
     const hasSafeRelations = new Map();
     for (const t of tableEntries)
         hasSafeRelations.set(t.name, typeSafeRelations(t, false).length > 0);
+    // F3: sibling-import extension. Defaults to '.js' for direct callers so their
+    // output stays byte-stable; `generate()` resolves it (auto / js / none).
+    const ext = options?.importExt ?? '.js';
     const lines = [
         ...generatedFileHeader(options),
+        // Record the resolved import mode for debuggability (only when generate()
+        // drove it, so direct generateIndex() callers stay byte-identical).
+        ...(options?.importMode ? [`// Sibling imports resolved with importExtension: ${options.importMode}.`, ''] : []),
         "import { TurbineClient as BaseTurbineClient, TransactionClient as BaseTransactionClient, QueryInterface } from 'turbine-orm';",
         "import type { TurbineConfig, TransactionOptions, DeferredQuery, PipelineResults } from 'turbine-orm';",
-        "import { SCHEMA } from './metadata.js';",
+        `import { SCHEMA } from './metadata${ext}';`,
     ];
     // Import all entity types and relations maps
     const typeImports = [];
@@ -584,7 +777,7 @@ export function generateIndex(schema, options) {
             typeImports.push(`${entityName(t.name)}Relations`);
         }
     }
-    lines.push(`import type { ${typeImports.join(', ')} } from './types.js';`);
+    lines.push(`import type { ${typeImports.join(', ')} } from './types${ext}';`);
     lines.push('');
     // -------------------------------------------------------------------------
     // TypedTransactionClient — same typed table accessors as TurbineClient,
@@ -695,11 +888,70 @@ export function generateIndex(schema, options) {
     lines.push('}');
     lines.push('');
     // Re-export everything
-    lines.push("export * from './types.js';");
-    lines.push("export { SCHEMA } from './metadata.js';");
+    lines.push(`export * from './types${ext}';`);
+    lines.push(`export { SCHEMA } from './metadata${ext}';`);
+    lines.push('');
+    return lines.join('\n');
+}
+// ---------------------------------------------------------------------------
+// prisma-map.ts generator
+// ---------------------------------------------------------------------------
+/**
+ * Serialize a resolved {@link PrismaCompatMap} into a `prisma-map.ts` module
+ * that exports `export const PRISMA_MAP: PrismaCompatMap = {...}`. Written next
+ * to the generated client by `turbine migrate-from-prisma`; consumed later by
+ * the phase-2 `turbine-orm/prisma-compat` runtime adapter.
+ *
+ * Deterministic: uses the same reproducible header as the other emitters, so a
+ * stable input regenerates byte-identical output under `noTimestamp`.
+ */
+export function generatePrismaMap(map, options) {
+    const lines = [
+        ...generatedFileHeader(options),
+        "import type { PrismaCompatMap } from 'turbine-orm';",
+        '',
+        '/**',
+        ' * Name map from your Prisma schema onto this Turbine client. Every entry was',
+        ' * resolved against the live database; unresolved items are omitted (see the',
+        ' * migration report). Pass this to the phase-2 prisma-compat adapter, or read',
+        ' * it directly for hand-written compatibility wrappers.',
+        ' */',
+        'export const PRISMA_MAP: PrismaCompatMap = {',
+        '  models: {',
+    ];
+    for (const [modelName, model] of Object.entries(map.models)) {
+        lines.push(`    ${quoteIfNeeded(modelName)}: {`);
+        lines.push(`      table: '${escSQ(model.table)}',`);
+        lines.push(`      accessor: '${escSQ(model.accessor)}',`);
+        lines.push(`      fields: ${serializeStringRecord(model.fields)},`);
+        lines.push('      relations: {');
+        for (const [rel, r] of Object.entries(model.relations)) {
+            lines.push(`        ${quoteIfNeeded(rel)}: { name: '${escSQ(r.name)}', cardinality: '${r.cardinality}' },`);
+        }
+        lines.push('      },');
+        lines.push(`      compoundUniques: ${serializeStringArrayRecord(model.compoundUniques)},`);
+        lines.push('    },');
+    }
+    lines.push('  },');
+    lines.push(`  enums: ${serializeStringRecord(map.enums)},`);
+    lines.push('};');
     lines.push('');
     return lines.join('\n');
 }
+/** Serialize a `Record<string, string>` as an inline object literal. */
+function serializeStringRecord(rec) {
+    const entries = Object.entries(rec);
+    if (entries.length === 0)
+        return '{}';
+    return `{ ${entries.map(([k, v]) => `${quoteIfNeeded(k)}: '${escSQ(v)}'`).join(', ')} }`;
+}
+/** Serialize a `Record<string, string[]>` as an inline object literal. */
+function serializeStringArrayRecord(rec) {
+    const entries = Object.entries(rec);
+    if (entries.length === 0)
+        return '{}';
+    return `{ ${entries.map(([k, v]) => `${quoteIfNeeded(k)}: [${v.map((s) => `'${escSQ(s)}'`).join(', ')}]`).join(', ')} }`;
+}
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------

package/dist/index.d.ts

@@ -45,8 +45,8 @@ export type { ObserveConfig, ObserveHandle } from './observe.js';
 export { executePipeline, type PipelineOptions, type PipelineResults, pipelineSupported } from './pipeline.js';
 export { type AggregateArgs, type AggregateResult, type ArrayFilter, type ColumnRef, type ConnectOrCreateOp, type CountArgs, type CreateArgs, type CreateDataInput, type CreateManyArgs, type DeferredQuery, type DeleteArgs, type DeleteManyArgs, type FieldResult, type FindManyArgs, type FindManyStreamArgs, type FindUniqueArgs, type GlobalFilters, type GroupByAggregateSpec, type GroupByArgs, type GroupByDistinctOn, type GroupByResult, type HavingClause, type JsonFilter, type JsonPathAggregateTarget, type JsonPathGroupKey, type JsonPathOrderBy, type MiddlewareFn, type NestedCreateOp, type NestedUpdateOp, type NestedUpdateOpItem, type NestedUpsertOpItem, type OmitResult, type OrderByClause, type OrderByObject, type OrderDirection, type QueryEvent, type QueryEventListener, QueryInterface, type QueryResult, type RelationDescriptor, type RelationFilter, type RelationLoadStrategy, type RelationPickBy, type RelationPickOrderBy, type SelectResult, type SkipGlobalFilters, type TextSearchFilter, type TypedWithClause, type UpdateArgs, type UpdateDataInput, type UpdateInput, type UpdateManyArgs, type UpdateOperatorInput, type UpsertArgs, type VectorDistanceFilter, type VectorFilter, type VectorMetric, type VectorOrderBy, type VectorOrderByDistance, type WhereClause, type WhereOperator, type WhereValue, type WithClause, type WithOptions, type WithOrderByObject, type WithResult, } from './query/index.js';
 export { type ActiveSubscription, type NotificationHandler, type Subscription, validateChannel } from './realtime.js';
-export type { CheckMetadata, ColumnMetadata, IndexMetadata, ReferentialAction, RelationDef, SchemaMetadata, TableMetadata, } from './schema.js';
-export { camelToSnake, isDateType, normalizeKeyColumns, pgArrayType, pgTypeToTs, singularize, snakeToCamel, snakeToPascal, } from './schema.js';
+export type { CheckMetadata, ColumnMetadata, IndexMetadata, PrismaCompatMap, PrismaModelMap, PrismaRelationMap, ReferentialAction, RelationDef, SchemaMetadata, TableMetadata, } from './schema.js';
+export { camelToSnake, isDateType, normalizeKeyColumns, pgArrayType, pgTypeToTs, singularize, snakeToCamel, snakeToPascal, withDbFieldNames, } from './schema.js';
 export { applyManyToManyRelations, type CheckDef, ColumnBuilder, type ColumnConfig, type ColumnDef, type ColumnIndexDef, type ColumnType, type ColumnTypeName, column, type DefineSchemaOptions, type DocFieldIndexDef, defineSchema, isDocFieldIndexDef, type ManyToManyDef, type ReferenceDef, type SchemaDef, type SchemaIndexDef, type TableDef, table, } from './schema-builder.js';
 export { schemaDefToMetadata } from './schema-metadata.js';
 export { type AlterColumnDef, type AlterDef, DestructivePushRefusal, type DiffResult, type PushResult, type SchemaSqlOptions, schemaDiff, schemaPush, schemaToSQL, schemaToSQLString, } from './schema-sql.js';

package/dist/index.js

@@ -51,7 +51,7 @@ export { QueryInterface, } from './query/index.js';
 // Realtime — LISTEN/NOTIFY pub/sub
 export { validateChannel } from './realtime.js';
 // Schema utilities
-export { camelToSnake, isDateType, normalizeKeyColumns, pgArrayType, pgTypeToTs, singularize, snakeToCamel, snakeToPascal, } from './schema.js';
+export { camelToSnake, isDateType, normalizeKeyColumns, pgArrayType, pgTypeToTs, singularize, snakeToCamel, snakeToPascal, withDbFieldNames, } from './schema.js';
 // Schema builder — define schemas in TypeScript
 export { applyManyToManyRelations, ColumnBuilder, column, defineSchema, isDocFieldIndexDef, 
 // Legacy compat (deprecated — use object format with defineSchema)