@prisma-next/target-postgres 0.4.0-dev.8 → 0.4.1

package/src/core/migrations/postgres-migration.ts

@@ -0,0 +1,20 @@
+import { Migration as SqlMigration } from '@prisma-next/family-sql/migration';
+import type { PostgresPlanTargetDetails } from './planner-target-details';
+
+/**
+ * Target-owned base class for Postgres migrations.
+ *
+ * Fixes the `SqlMigration` generic to `PostgresPlanTargetDetails` and the
+ * abstract `targetId` to the Postgres target-id string literal, so both
+ * user-authored migrations and renderer-generated scaffolds (the output of
+ * `renderCallsToTypeScript`) can extend `PostgresMigration` directly without
+ * redeclaring target-local identity.
+ *
+ * Mirrors `MongoMigration` in `@prisma-next/family-mongo`: the renderer
+ * emits `extends Migration` against a target-specific re-export of this
+ * class from `@prisma-next/target-postgres/migration`, keeping the
+ * authoring surface target-scoped rather than family-scoped.
+ */
+export abstract class PostgresMigration extends SqlMigration<PostgresPlanTargetDetails> {
+  readonly targetId = 'postgres' as const;
+}

package/src/core/migrations/render-ops.ts

@@ -0,0 +1,9 @@
+import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';
+import type { PostgresOpFactoryCall } from './op-factory-call';
+import type { PostgresPlanTargetDetails } from './planner-target-details';
+
+type Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
+
+export function renderOps(calls: readonly PostgresOpFactoryCall[]): Op[] {
+  return calls.map((c) => c.toOp());
+}

package/src/core/migrations/render-typescript.ts

@@ -0,0 +1,95 @@
+/**
+ * Polymorphic TypeScript emitter for the Postgres migration IR.
+ *
+ * Each `PostgresOpFactoryCall` renders itself via `renderTypeScript()` and
+ * declares its own `importRequirements()`; this file just composes the module
+ * source around those contributions. The design mirrors the Mongo target's
+ * `render-typescript.ts` deliberately — byte-for-byte alignment isn't required
+ * (different factory module specifiers, different base-class name) but the
+ * shape is, so future consolidation to a framework-level helper is mechanical.
+ */
+
+import { detectScaffoldRuntime, shebangLineFor } from '@prisma-next/migration-tools/migration-ts';
+import { type ImportRequirement, jsonToTsSource, renderImports } from '@prisma-next/ts-render';
+import type { PostgresOpFactoryCall } from './op-factory-call';
+
+export interface RenderMigrationMeta {
+  readonly from: string;
+  readonly to: string;
+  readonly kind?: string;
+  readonly labels?: readonly string[];
+}
+
+/**
+ * Always-present base import — the rendered scaffold always extends the
+ * target-owned `Migration` (i.e. `PostgresMigration`) re-exported from
+ * `@prisma-next/target-postgres/migration`. That re-export fixes the
+ * `SqlMigration` generic to `PostgresPlanTargetDetails` and the abstract
+ * `targetId` to `'postgres'`, so user-authored migrations don't need to
+ * thread target-details or redeclare `targetId`.
+ */
+const BASE_IMPORT: ImportRequirement = {
+  moduleSpecifier: '@prisma-next/target-postgres/migration',
+  symbol: 'Migration',
+};
+
+export function renderCallsToTypeScript(
+  calls: ReadonlyArray<PostgresOpFactoryCall>,
+  meta: RenderMigrationMeta,
+): string {
+  const imports = buildImports(calls);
+  const operationsBody = calls.map((c) => c.renderTypeScript()).join(',\n');
+
+  return [
+    shebangLineFor(detectScaffoldRuntime()),
+    imports,
+    '',
+    'export default class M extends Migration {',
+    buildDescribeMethod(meta),
+    '  override get operations() {',
+    '    return [',
+    indent(operationsBody, 6),
+    '    ];',
+    '  }',
+    '}',
+    '',
+    'Migration.run(import.meta.url, M);',
+    '',
+  ].join('\n');
+}
+
+function buildImports(calls: ReadonlyArray<PostgresOpFactoryCall>): string {
+  const requirements: ImportRequirement[] = [BASE_IMPORT];
+  for (const call of calls) {
+    for (const req of call.importRequirements()) {
+      requirements.push(req);
+    }
+  }
+  return renderImports(requirements);
+}
+
+function buildDescribeMethod(meta: RenderMigrationMeta): string {
+  const lines: string[] = [];
+  lines.push('  override describe() {');
+  lines.push('    return {');
+  lines.push(`      from: ${JSON.stringify(meta.from)},`);
+  lines.push(`      to: ${JSON.stringify(meta.to)},`);
+  if (meta.kind) {
+    lines.push(`      kind: ${JSON.stringify(meta.kind)},`);
+  }
+  if (meta.labels && meta.labels.length > 0) {
+    lines.push(`      labels: ${jsonToTsSource(meta.labels)},`);
+  }
+  lines.push('    };');
+  lines.push('  }');
+  lines.push('');
+  return lines.join('\n');
+}
+
+function indent(text: string, spaces: number): string {
+  const pad = ' '.repeat(spaces);
+  return text
+    .split('\n')
+    .map((line) => (line.trim() ? `${pad}${line}` : line))
+    .join('\n');
+}

package/src/exports/control.ts

@@ -1,86 +1,21 @@
-import {
-  normalizeSchemaNativeType,
-  parsePostgresDefault,
-} from '@prisma-next/adapter-postgres/control';
 import type { ColumnDefault, Contract } from '@prisma-next/contract/types';
 import type {
   SqlControlFamilyInstance,
   SqlControlTargetDescriptor,
 } from '@prisma-next/family-sql/control';
-import {
-  collectInitDependencies,
-  contractToSchemaIR,
-  extractCodecControlHooks,
-} from '@prisma-next/family-sql/control';
-import { MigrationDescriptorArraySchema } from '@prisma-next/family-sql/operation-descriptors';
-import { verifySqlSchema } from '@prisma-next/family-sql/schema-verify';
+import { contractToSchemaIR, extractCodecControlHooks } from '@prisma-next/family-sql/control';
 import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
 import type {
   ControlTargetInstance,
   MigrationRunner,
-  OperationDescriptor,
 } from '@prisma-next/framework-components/control';
-import { sql } from '@prisma-next/sql-builder/runtime';
 import type { SqlStorage, StorageColumn } from '@prisma-next/sql-contract/types';
-import type { SqlOperationEntry } from '@prisma-next/sql-operations';
 import { ifDefined } from '@prisma-next/utils/defined';
-import { type } from 'arktype';
 import { postgresTargetDescriptorMeta } from '../core/descriptor-meta';
-import { planDescriptors } from '../core/migrations/descriptor-planner';
-import { resolveOperations } from '../core/migrations/operation-resolver';
 import { createPostgresMigrationPlanner } from '../core/migrations/planner';
 import { renderDefaultLiteral } from '../core/migrations/planner-ddl-builders';
 import type { PostgresPlanTargetDetails } from '../core/migrations/planner-target-details';
 import { createPostgresMigrationRunner } from '../core/migrations/runner';
-import { renderDescriptorTypeScript } from '../core/migrations/scaffolding';
-
-function parseDescriptors(descriptors: readonly OperationDescriptor[]) {
-  const result = MigrationDescriptorArraySchema([...descriptors]);
-  if (result instanceof type.errors) {
-    throw new Error(`Invalid migration descriptors:\n${result.summary}`);
-  }
-  return result;
-}
-
-function collectQueryOperationTypes(
-  frameworkComponents?: ReadonlyArray<TargetBoundComponentDescriptor<'sql', 'postgres'>>,
-): Readonly<Record<string, SqlOperationEntry>> {
-  const entries: Record<string, SqlOperationEntry> = {};
-  if (!frameworkComponents) return entries;
-  for (const component of frameworkComponents) {
-    const ops = (
-      component as {
-        queryOperations?: () => ReadonlyArray<{ method: string } & SqlOperationEntry>;
-      }
-    ).queryOperations?.();
-    if (!ops) continue;
-    for (const { method, ...entry } of ops) {
-      entries[method] = entry;
-    }
-  }
-  return entries;
-}
-
-/**
- * Creates a SQL DSL client for migration authoring.
- * Only the fields used by the builder are populated — operations, codecs,
- * and types are unused by sql() and stubbed to satisfy the ExecutionContext type.
- */
-function createMigrationClient(
-  toContract: Contract<SqlStorage>,
-  frameworkComponents?: ReadonlyArray<TargetBoundComponentDescriptor<'sql', 'postgres'>>,
-) {
-  const queryOperationTypes = collectQueryOperationTypes(frameworkComponents);
-  // sql() only reads contract, queryOperations.entries(), and applyMutationDefaults
-  // from the context. The other fields are for runtime execution, not query building.
-  return sql({
-    context: {
-      contract: toContract,
-      queryOperations: { entries: () => queryOperationTypes },
-      applyMutationDefaults: () => [],
-    } as never,
-  });
-}
 
 function buildNativeTypeExpander(
   frameworkComponents?: ReadonlyArray<TargetBoundComponentDescriptor<'sql', 'postgres'>>,
@@ -95,22 +30,15 @@ function buildNativeTypeExpander(
     readonly typeParams?: Record<string, unknown>;
   }) => {
     if (!input.typeParams) return input.nativeType;
-
-    if (!input.codecId) {
-      throw new Error(
-        `Column declares typeParams for nativeType "${input.nativeType}" but has no codecId. ` +
-          'Ensure the column is associated with a codec.',
-      );
-    }
-
+    // Mirror `renderExpectedNativeType` in verify-sql-schema: when a codec
+    // has no `expandNativeType` hook (e.g. `pg/enum@1`, whose typeParams
+    // describe the value set rather than a DDL suffix), fall back to the
+    // bare native type rather than throwing. Throwing here would reject
+    // every plan involving an enum-/values-typed column as soon as its
+    // `typeRef` resolved to a `StorageTypeInstance` carrying typeParams.
+    if (!input.codecId) return input.nativeType;
     const hooks = codecHooks.get(input.codecId);
-    if (!hooks?.expandNativeType) {
-      throw new Error(
-        `Column declares typeParams for nativeType "${input.nativeType}" ` +
-          `but no expandNativeType hook is registered for codecId "${input.codecId}". ` +
-          'Ensure the extension providing this codec is included in extensionPacks.',
-      );
-    }
+    if (!hooks?.expandNativeType) return input.nativeType;
     return hooks.expandNativeType(input);
   };
 }
@@ -141,67 +69,6 @@ const postgresTargetDescriptor: SqlControlTargetDescriptor<'postgres', PostgresP
           frameworkComponents: frameworkComponents ?? [],
         });
       },
-      planWithDescriptors(context) {
-        const toContract = context.toContract as Contract<SqlStorage>;
-        const fromContract = context.fromContract as Contract<SqlStorage> | null;
-
-        // Synthesize schema IR from the fromContract (same as contractToSchema flow)
-        const expander = buildNativeTypeExpander(context.frameworkComponents);
-        const fromSchemaIR = contractToSchemaIR(fromContract, {
-          annotationNamespace: 'pg',
-          ...ifDefined('expandNativeType', expander),
-          renderDefault: postgresRenderDefault,
-          frameworkComponents: context.frameworkComponents ?? [],
-        });
-
-        // Collect schema issues via verifier
-        const verifyResult = verifySqlSchema({
-          contract: toContract,
-          schema: fromSchemaIR,
-          strict: true,
-          typeMetadataRegistry: new Map(),
-          frameworkComponents: context.frameworkComponents ?? [],
-          normalizeDefault: parsePostgresDefault,
-          normalizeNativeType: normalizeSchemaNativeType,
-        });
-
-        // Run descriptor planner
-        const planResult = planDescriptors({
-          issues: verifyResult.schema.issues,
-          toContract,
-          fromContract,
-        });
-        if (!planResult.ok) {
-          return { ok: false as const, conflicts: planResult.failure };
-        }
-
-        return {
-          ok: true as const,
-          descriptors: planResult.value.descriptors,
-        };
-      },
-
-      resolveDescriptors(descriptors, context) {
-        const validated = parseDescriptors(descriptors);
-        const codecHooks = context.frameworkComponents
-          ? extractCodecControlHooks(context.frameworkComponents)
-          : new Map();
-        const dependencies = context.frameworkComponents
-          ? collectInitDependencies(context.frameworkComponents)
-          : [];
-        const toContract = context.toContract as Contract<SqlStorage>;
-        const db = createMigrationClient(toContract, context.frameworkComponents);
-        return resolveOperations(validated, {
-          toContract,
-          schemaName: context.schemaName ?? 'public',
-          codecHooks,
-          dependencies,
-          db,
-        });
-      },
-      renderDescriptorTypeScript(descriptors, context) {
-        return renderDescriptorTypeScript(descriptors, context);
-      },
     },
     create(): ControlTargetInstance<'sql', 'postgres'> {
       return {

package/src/exports/migration.ts

@@ -0,0 +1,40 @@
+// Re-exported so user-edited migration.ts files only need to depend on
+// `@prisma-next/target-postgres/migration` to fill in planner-emitted
+// `placeholder("…")` slots, instead of pulling in `@prisma-next/errors`
+// directly. The planner emits an import from this same module.
+export { placeholder } from '@prisma-next/errors/migration';
+export {
+  addColumn,
+  alterColumnType,
+  dropColumn,
+  dropDefault,
+  dropNotNull,
+  setDefault,
+  setNotNull,
+} from '../core/migrations/operations/columns';
+export {
+  addForeignKey,
+  addPrimaryKey,
+  addUnique,
+  dropConstraint,
+} from '../core/migrations/operations/constraints';
+export {
+  type DataTransformClosure,
+  type DataTransformOptions,
+  dataTransform,
+} from '../core/migrations/operations/data-transform';
+export { createExtension, createSchema } from '../core/migrations/operations/dependencies';
+export {
+  addEnumValues,
+  createEnumType,
+  dropEnumType,
+  renameType,
+} from '../core/migrations/operations/enums';
+export { createIndex, dropIndex } from '../core/migrations/operations/indexes';
+export { rawSql } from '../core/migrations/operations/raw';
+export { createTable, dropTable } from '../core/migrations/operations/tables';
+// Target-owned base class for migrations. Aliased to `Migration` so
+// user-edited migration.ts files (and the renderer's scaffold) read as
+// `class M extends Migration { … }` without having to thread the
+// target-details generic or redeclare `targetId`.
+export { PostgresMigration as Migration } from '../core/migrations/postgres-migration';

package/dist/migration-builders.d.mts

@@ -1,88 +0,0 @@
-import * as _prisma_next_family_sql_operation_descriptors0 from "@prisma-next/family-sql/operation-descriptors";
-import { AddColumnDescriptor, AddEnumValuesDescriptor, AddForeignKeyDescriptor, AddPrimaryKeyDescriptor, AddUniqueDescriptor, AlterColumnTypeDescriptor, Buildable, Buildable as Buildable$1, CreateDependencyDescriptor, CreateEnumTypeDescriptor, CreateIndexDescriptor, CreateTableDescriptor, DataTransformDescriptor, DropColumnDescriptor, DropConstraintDescriptor, DropDefaultDescriptor, DropEnumTypeDescriptor, DropIndexDescriptor, DropNotNullDescriptor, DropTableDescriptor, RenameTypeDescriptor, SetDefaultDescriptor, SetNotNullDescriptor, SqlMigrationOpDescriptor, SqlMigrationOpDescriptor as SqlMigrationOpDescriptor$1, TODO, TodoMarker, TodoMarker as TodoMarker$1, addColumn, addEnumValues, addForeignKey, addPrimaryKey, addUnique, alterColumnType, createDependency, createEnumType, createIndex, createTable, dropColumn, dropConstraint, dropDefault, dropEnumType, dropIndex, dropNotNull, dropTable, renameType, setDefault, setNotNull } from "@prisma-next/family-sql/operation-descriptors";
-import { Db, TableProxyContract } from "@prisma-next/sql-builder/types";
-import { SqlQueryPlan } from "@prisma-next/sql-relational-core/plan";
-
-//#region src/core/migrations/operation-descriptors.d.ts
-
-/**
- * A single query plan input — callback, pre-built plan, or TODO placeholder.
- * @template TContract - The contract type for the Db client. Defaults to any
- *   (untyped). Use createBuilders<Contract>() to get typed callbacks.
- */
-type QueryPlanInput<TContract extends TableProxyContract = any> = ((db: Db<TContract>) => Buildable$1) | SqlQueryPlan | TodoMarker$1;
-/** Run input — a callback returning one or many buildables, or a pre-built plan/TODO. */
-type RunInput<TContract extends TableProxyContract = any> = ((db: Db<TContract>) => Buildable$1 | readonly Buildable$1[]) | SqlQueryPlan | TodoMarker$1;
-type PostgresMigrationOpDescriptor = SqlMigrationOpDescriptor$1 | DataTransformDescriptor;
-declare function dataTransform<TContract extends TableProxyContract = any>(name: string, options: {
-  check: QueryPlanInput<TContract> | Buildable$1 | boolean;
-  run: RunInput<TContract> | Buildable$1;
-}): DataTransformDescriptor;
-/**
- * Creates typed migration builder functions parameterized by the contract type.
- * The dataTransform callback receives a fully typed Db<TContract> client.
- *
- * Usage:
- * ```typescript
- * import type { Contract } from "../../src/prisma/contract.d"
- * import { createBuilders } from "@prisma-next/target-postgres/migration-builders"
- *
- * const { addColumn, dataTransform, setNotNull } = createBuilders<Contract>()
- * ```
- */
-declare function createBuilders<TContract extends TableProxyContract>(): {
-  dataTransform: (name: string, options: {
-    check: boolean | Buildable$1 | QueryPlanInput<TContract>;
-    run: Buildable$1 | RunInput<TContract>;
-  }) => DataTransformDescriptor;
-  TODO: symbol;
-  createTable: typeof _prisma_next_family_sql_operation_descriptors0.createTable;
-  dropTable: typeof _prisma_next_family_sql_operation_descriptors0.dropTable;
-  addColumn: typeof _prisma_next_family_sql_operation_descriptors0.addColumn;
-  dropColumn: typeof _prisma_next_family_sql_operation_descriptors0.dropColumn;
-  alterColumnType: typeof _prisma_next_family_sql_operation_descriptors0.alterColumnType;
-  setNotNull: typeof _prisma_next_family_sql_operation_descriptors0.setNotNull;
-  dropNotNull: typeof _prisma_next_family_sql_operation_descriptors0.dropNotNull;
-  setDefault: typeof _prisma_next_family_sql_operation_descriptors0.setDefault;
-  dropDefault: typeof _prisma_next_family_sql_operation_descriptors0.dropDefault;
-  addPrimaryKey: typeof _prisma_next_family_sql_operation_descriptors0.addPrimaryKey;
-  addUnique: typeof _prisma_next_family_sql_operation_descriptors0.addUnique;
-  addForeignKey: typeof _prisma_next_family_sql_operation_descriptors0.addForeignKey;
-  dropConstraint: typeof _prisma_next_family_sql_operation_descriptors0.dropConstraint;
-  createIndex: typeof _prisma_next_family_sql_operation_descriptors0.createIndex;
-  dropIndex: typeof _prisma_next_family_sql_operation_descriptors0.dropIndex;
-  createEnumType: typeof _prisma_next_family_sql_operation_descriptors0.createEnumType;
-  addEnumValues: typeof _prisma_next_family_sql_operation_descriptors0.addEnumValues;
-  dropEnumType: typeof _prisma_next_family_sql_operation_descriptors0.dropEnumType;
-  renameType: typeof _prisma_next_family_sql_operation_descriptors0.renameType;
-  createDependency: typeof _prisma_next_family_sql_operation_descriptors0.createDependency;
-};
-/**
- * All builder functions keyed by descriptor kind.
- */
-declare const builders: {
-  readonly dataTransform: typeof dataTransform;
-  readonly createTable: typeof _prisma_next_family_sql_operation_descriptors0.createTable;
-  readonly dropTable: typeof _prisma_next_family_sql_operation_descriptors0.dropTable;
-  readonly addColumn: typeof _prisma_next_family_sql_operation_descriptors0.addColumn;
-  readonly dropColumn: typeof _prisma_next_family_sql_operation_descriptors0.dropColumn;
-  readonly alterColumnType: typeof _prisma_next_family_sql_operation_descriptors0.alterColumnType;
-  readonly setNotNull: typeof _prisma_next_family_sql_operation_descriptors0.setNotNull;
-  readonly dropNotNull: typeof _prisma_next_family_sql_operation_descriptors0.dropNotNull;
-  readonly setDefault: typeof _prisma_next_family_sql_operation_descriptors0.setDefault;
-  readonly dropDefault: typeof _prisma_next_family_sql_operation_descriptors0.dropDefault;
-  readonly addPrimaryKey: typeof _prisma_next_family_sql_operation_descriptors0.addPrimaryKey;
-  readonly addUnique: typeof _prisma_next_family_sql_operation_descriptors0.addUnique;
-  readonly addForeignKey: typeof _prisma_next_family_sql_operation_descriptors0.addForeignKey;
-  readonly dropConstraint: typeof _prisma_next_family_sql_operation_descriptors0.dropConstraint;
-  readonly createIndex: typeof _prisma_next_family_sql_operation_descriptors0.createIndex;
-  readonly dropIndex: typeof _prisma_next_family_sql_operation_descriptors0.dropIndex;
-  readonly createEnumType: typeof _prisma_next_family_sql_operation_descriptors0.createEnumType;
-  readonly addEnumValues: typeof _prisma_next_family_sql_operation_descriptors0.addEnumValues;
-  readonly dropEnumType: typeof _prisma_next_family_sql_operation_descriptors0.dropEnumType;
-  readonly renameType: typeof _prisma_next_family_sql_operation_descriptors0.renameType;
-  readonly createDependency: typeof _prisma_next_family_sql_operation_descriptors0.createDependency;
-};
-//#endregion
-export { type AddColumnDescriptor, type AddEnumValuesDescriptor, type AddForeignKeyDescriptor, type AddPrimaryKeyDescriptor, type AddUniqueDescriptor, type AlterColumnTypeDescriptor, type Buildable, type CreateDependencyDescriptor, type CreateEnumTypeDescriptor, type CreateIndexDescriptor, type CreateTableDescriptor, type DataTransformDescriptor, type DropColumnDescriptor, type DropConstraintDescriptor, type DropDefaultDescriptor, type DropEnumTypeDescriptor, type DropIndexDescriptor, type DropNotNullDescriptor, type DropTableDescriptor, type PostgresMigrationOpDescriptor, type QueryPlanInput, type RenameTypeDescriptor, type RunInput, type SetDefaultDescriptor, type SetNotNullDescriptor, type SqlMigrationOpDescriptor, TODO, type TodoMarker, addColumn, addEnumValues, addForeignKey, addPrimaryKey, addUnique, alterColumnType, builders, createBuilders, createDependency, createEnumType, createIndex, createTable, dataTransform, dropColumn, dropConstraint, dropDefault, dropEnumType, dropIndex, dropNotNull, dropTable, renameType, setDefault, setNotNull };
-//# sourceMappingURL=migration-builders.d.mts.map

package/dist/migration-builders.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"migration-builders.d.mts","names":[],"sources":["../src/core/migrations/operation-descriptors.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;AAsFA;;AACa,KARD,cAQC,CAAA,kBARgC,kBAQhC,GAAA,GAAA,CAAA,GAAA,CAAA,CAAA,EAAA,EAPH,EAOG,CAPA,SAOA,CAAA,EAAA,GAPe,WAOf,CAAA,GANT,YAMS,GALT,YAKS;;AAAe,KADhB,QACgB,CAAA,kBADW,kBACX,GAAA,GAAA,CAAA,GAAA,CAAA,CAAA,EAAA,EAAlB,EAAkB,CAAf,SAAe,CAAA,EAAA,GAAA,WAAA,GAAA,SAAqB,WAArB,EAAA,CAAA,GACxB,YADwB,GAExB,YAFwB;AAAqB,KAQrC,6BAAA,GAAgC,0BARK,GAQsB,uBARtB;AAC7C,iBAsBY,aAtBZ,CAAA,kBAsB4C,kBAtB5C,GAAA,GAAA,CAAA,CAAA,IAAA,EAAA,MAAA,EAAA,OAAA,EAAA;EACA,KAAA,EAwBO,cAxBP,CAwBsB,SAxBtB,CAAA,GAwBmC,WAxBnC,GAAA,OAAA;EAAU,GAAA,EAyBL,QAzBK,CAyBI,SAzBJ,CAAA,GAyBiB,WAzBjB;AAMd,CAAA,CAAA,EAqBG,uBArBS;AAeZ;;;;;;;;;;AAyCA;;iBAAgB,iCAAiC;;;;QAnC9C;;EAAA,WAAA,EAAA,OAAuB,8CAAA,CAAA,WAAvB;EAAuB,SAAA,EAAA,+DAAA;;;;;;;;;;;;;;;;;;;;;AA8C1B;;cAAa"}

package/dist/migration-builders.mjs

@@ -1,3 +0,0 @@
-import { C as setDefault, S as renameType, _ as dropDefault, a as addPrimaryKey, b as dropNotNull, c as builders, d as createEnumType, f as createIndex, g as dropConstraint, h as dropColumn, i as addForeignKey, l as createBuilders, m as dataTransform, n as addColumn, o as addUnique, p as createTable, r as addEnumValues, s as alterColumnType, t as TODO, u as createDependency, v as dropEnumType, w as setNotNull, x as dropTable, y as dropIndex } from "./operation-descriptors-CxymFSgK.mjs";
-
-export { TODO, addColumn, addEnumValues, addForeignKey, addPrimaryKey, addUnique, alterColumnType, builders, createBuilders, createDependency, createEnumType, createIndex, createTable, dataTransform, dropColumn, dropConstraint, dropDefault, dropEnumType, dropIndex, dropNotNull, dropTable, renameType, setDefault, setNotNull };

package/dist/operation-descriptors-CxymFSgK.mjs

@@ -1,52 +0,0 @@
-import { TODO, TODO as TODO$1, addColumn, addEnumValues, addForeignKey, addPrimaryKey, addUnique, alterColumnType, builders, createDependency, createEnumType, createIndex, createTable, dropColumn, dropConstraint, dropDefault, dropEnumType, dropIndex, dropNotNull, dropTable, renameType, setDefault, setNotNull } from "@prisma-next/family-sql/operation-descriptors";
-
-//#region src/core/migrations/operation-descriptors.ts
-function resolveInput(input) {
-	if (typeof input === "symbol" || typeof input === "function") return input;
-	if ("build" in input && typeof input.build === "function") return input.build();
-	return input;
-}
-function dataTransform(name, options) {
-	const check = typeof options.check === "boolean" ? options.check : resolveInput(options.check);
-	const run = [];
-	if (typeof options.run === "function") run.push(options.run);
-	else if (typeof options.run === "symbol") run.push(options.run);
-	else run.push(resolveInput(options.run));
-	return {
-		kind: "dataTransform",
-		name,
-		source: "migration.ts",
-		check,
-		run
-	};
-}
-/**
-* Creates typed migration builder functions parameterized by the contract type.
-* The dataTransform callback receives a fully typed Db<TContract> client.
-*
-* Usage:
-* ```typescript
-* import type { Contract } from "../../src/prisma/contract.d"
-* import { createBuilders } from "@prisma-next/target-postgres/migration-builders"
-*
-* const { addColumn, dataTransform, setNotNull } = createBuilders<Contract>()
-* ```
-*/
-function createBuilders() {
-	return {
-		...builders,
-		dataTransform,
-		TODO
-	};
-}
-/**
-* All builder functions keyed by descriptor kind.
-*/
-const builders$1 = {
-	...builders,
-	dataTransform
-};
-
-//#endregion
-export { setDefault as C, renameType as S, dropDefault as _, addPrimaryKey as a, dropNotNull as b, builders$1 as c, createEnumType as d, createIndex as f, dropConstraint as g, dropColumn as h, addForeignKey as i, createBuilders as l, dataTransform as m, addColumn as n, addUnique as o, createTable as p, addEnumValues as r, alterColumnType as s, TODO$1 as t, createDependency as u, dropEnumType as v, setNotNull as w, dropTable as x, dropIndex as y };
-//# sourceMappingURL=operation-descriptors-CxymFSgK.mjs.map

package/dist/operation-descriptors-CxymFSgK.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"operation-descriptors-CxymFSgK.mjs","names":["run: (symbol | object | ((...args: never[]) => unknown))[]","structuralBuilders","builders"],"sources":["../src/core/migrations/operation-descriptors.ts"],"sourcesContent":["/**\n * Postgres migration operation descriptors.\n *\n * Re-exports all structural SQL descriptors from @prisma-next/family-sql\n * and adds data transform support with typed query builder callbacks.\n */\n\nimport type { Db, TableProxyContract } from '@prisma-next/sql-builder/types';\nimport type { SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';\n\n// Re-export structural descriptors from sql-family\nexport {\n  type AddColumnDescriptor,\n  type AddEnumValuesDescriptor,\n  type AddForeignKeyDescriptor,\n  type AddPrimaryKeyDescriptor,\n  type AddUniqueDescriptor,\n  type AlterColumnTypeDescriptor,\n  addColumn,\n  addEnumValues,\n  addForeignKey,\n  addPrimaryKey,\n  addUnique,\n  alterColumnType,\n  type Buildable,\n  type CreateDependencyDescriptor,\n  type CreateEnumTypeDescriptor,\n  type CreateIndexDescriptor,\n  type CreateTableDescriptor,\n  createDependency,\n  createEnumType,\n  createIndex,\n  createTable,\n  type DropColumnDescriptor,\n  type DropConstraintDescriptor,\n  type DropDefaultDescriptor,\n  type DropEnumTypeDescriptor,\n  type DropIndexDescriptor,\n  type DropNotNullDescriptor,\n  type DropTableDescriptor,\n  dropColumn,\n  dropConstraint,\n  dropDefault,\n  dropEnumType,\n  dropIndex,\n  dropNotNull,\n  dropTable,\n  type RenameTypeDescriptor,\n  renameType,\n  type SetDefaultDescriptor,\n  type SetNotNullDescriptor,\n  type SqlMigrationOpDescriptor,\n  setDefault,\n  setNotNull,\n  TODO,\n  type TodoMarker,\n} from '@prisma-next/family-sql/operation-descriptors';\n\nimport {\n  type Buildable,\n  type DataTransformDescriptor,\n  type SqlMigrationOpDescriptor,\n  builders as structuralBuilders,\n  TODO,\n  type TodoMarker,\n} from '@prisma-next/family-sql/operation-descriptors';\n\nexport type { DataTransformDescriptor };\n\n// ============================================================================\n// Typed data transform inputs (for createBuilders<Contract>())\n// ============================================================================\n\n/**\n * A single query plan input — callback, pre-built plan, or TODO placeholder.\n * @template TContract - The contract type for the Db client. Defaults to any\n *   (untyped). Use createBuilders<Contract>() to get typed callbacks.\n */\n// biome-ignore lint/suspicious/noExplicitAny: default is untyped; createBuilders narrows this\nexport type QueryPlanInput<TContract extends TableProxyContract = any> =\n  | ((db: Db<TContract>) => Buildable)\n  | SqlQueryPlan\n  | TodoMarker;\n\n/** Run input — a callback returning one or many buildables, or a pre-built plan/TODO. */\n// biome-ignore lint/suspicious/noExplicitAny: default is untyped; createBuilders narrows this\nexport type RunInput<TContract extends TableProxyContract = any> =\n  | ((db: Db<TContract>) => Buildable | readonly Buildable[])\n  | SqlQueryPlan\n  | TodoMarker;\n\n// ============================================================================\n// Postgres descriptor union = SQL structural + data transforms\n// ============================================================================\n\nexport type PostgresMigrationOpDescriptor = SqlMigrationOpDescriptor | DataTransformDescriptor;\n\n// ============================================================================\n// Data transform builder\n// ============================================================================\n\nfunction resolveInput(input: QueryPlanInput): QueryPlanInput {\n  if (typeof input === 'symbol' || typeof input === 'function') return input;\n  if ('build' in input && typeof (input as Buildable).build === 'function') {\n    return (input as Buildable).build();\n  }\n  return input;\n}\n\n// biome-ignore lint/suspicious/noExplicitAny: default is untyped; createBuilders narrows this\nexport function dataTransform<TContract extends TableProxyContract = any>(\n  name: string,\n  options: {\n    check: QueryPlanInput<TContract> | Buildable | boolean;\n    run: RunInput<TContract> | Buildable;\n  },\n): DataTransformDescriptor {\n  const check =\n    typeof options.check === 'boolean'\n      ? options.check\n      : resolveInput(options.check as QueryPlanInput);\n\n  const run: (symbol | object | ((...args: never[]) => unknown))[] = [];\n  if (typeof options.run === 'function') {\n    run.push(options.run);\n  } else if (typeof options.run === 'symbol') {\n    run.push(options.run);\n  } else {\n    run.push(resolveInput(options.run as QueryPlanInput));\n  }\n  return {\n    kind: 'dataTransform' as const,\n    name,\n    source: 'migration.ts',\n    check,\n    run,\n  };\n}\n\n/**\n * Creates typed migration builder functions parameterized by the contract type.\n * The dataTransform callback receives a fully typed Db<TContract> client.\n *\n * Usage:\n * ```typescript\n * import type { Contract } from \"../../src/prisma/contract.d\"\n * import { createBuilders } from \"@prisma-next/target-postgres/migration-builders\"\n *\n * const { addColumn, dataTransform, setNotNull } = createBuilders<Contract>()\n * ```\n */\nexport function createBuilders<TContract extends TableProxyContract>() {\n  return {\n    ...structuralBuilders,\n    dataTransform: dataTransform<TContract>,\n    TODO,\n  };\n}\n\n/**\n * All builder functions keyed by descriptor kind.\n */\nexport const builders = {\n  ...structuralBuilders,\n  dataTransform,\n} as const;\n"],"mappings":";;;AAqGA,SAAS,aAAa,OAAuC;AAC3D,KAAI,OAAO,UAAU,YAAY,OAAO,UAAU,WAAY,QAAO;AACrE,KAAI,WAAW,SAAS,OAAQ,MAAoB,UAAU,WAC5D,QAAQ,MAAoB,OAAO;AAErC,QAAO;;AAIT,SAAgB,cACd,MACA,SAIyB;CACzB,MAAM,QACJ,OAAO,QAAQ,UAAU,YACrB,QAAQ,QACR,aAAa,QAAQ,MAAwB;CAEnD,MAAMA,MAA6D,EAAE;AACrE,KAAI,OAAO,QAAQ,QAAQ,WACzB,KAAI,KAAK,QAAQ,IAAI;UACZ,OAAO,QAAQ,QAAQ,SAChC,KAAI,KAAK,QAAQ,IAAI;KAErB,KAAI,KAAK,aAAa,QAAQ,IAAsB,CAAC;AAEvD,QAAO;EACL,MAAM;EACN;EACA,QAAQ;EACR;EACA;EACD;;;;;;;;;;;;;;AAeH,SAAgB,iBAAuD;AACrE,QAAO;EACL,GAAGC;EACY;EACf;EACD;;;;;AAMH,MAAaC,aAAW;CACtB,GAAGD;CACH;CACD"}