@prisma-next/target-postgres 0.4.0-dev.9 → 0.4.2

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

@@ -0,0 +1,73 @@
+import type { Contract } from '@prisma-next/contract/types';
+import type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';
+import { Migration as SqlMigration } from '@prisma-next/family-sql/migration';
+import type { ControlStack } from '@prisma-next/framework-components/control';
+import type { SqlStorage } from '@prisma-next/sql-contract/types';
+import { errorPostgresMigrationStackMissing } from '../errors';
+import {
+  type DataTransformOptions,
+  dataTransform,
+  type PostgresDataTransformOperation,
+} from './operations/data-transform';
+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.
+ *
+ * The constructor materializes a single Postgres `SqlControlAdapter` from
+ * `stack.adapter.create(stack)` and stores it; the protected `dataTransform`
+ * instance method forwards to the free `dataTransform` factory with that
+ * stored adapter, so user migrations can write `this.dataTransform(...)`
+ * without threading the adapter through every call.
+ */
+export abstract class PostgresMigration extends SqlMigration<
+  PostgresPlanTargetDetails,
+  'postgres'
+> {
+  readonly targetId = 'postgres' as const;
+
+  /**
+   * Materialized Postgres control adapter, created once per migration
+   * instance from the injected stack. `undefined` only when the migration
+   * was instantiated without a stack (test fixtures); `dataTransform`
+   * throws in that case to surface the misuse.
+   */
+  protected readonly controlAdapter: SqlControlAdapter<'postgres'> | undefined;
+
+  constructor(stack?: ControlStack<'sql', 'postgres'>) {
+    super(stack);
+    // The descriptor `create()` is typed as the wider `ControlAdapterInstance`;
+    // the Postgres descriptor concretely returns a `SqlControlAdapter<'postgres'>`,
+    // so the cast holds for any Postgres-target stack assembled at runtime.
+    this.controlAdapter = stack?.adapter
+      ? (stack.adapter.create(stack) as SqlControlAdapter<'postgres'>)
+      : undefined;
+  }
+
+  /**
+   * Instance-method wrapper around the free `dataTransform` factory that
+   * supplies the stored control adapter. Authors call this from inside
+   * `get operations()`; the adapter argument is hidden from the call site.
+   */
+  protected dataTransform<TContract extends Contract<SqlStorage>>(
+    contract: TContract,
+    name: string,
+    options: DataTransformOptions,
+  ): PostgresDataTransformOperation {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return dataTransform(contract, name, options, this.controlAdapter);
+  }
+}

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,105 @@
+/**
+ * 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 imports for the rendered scaffold. Both come from
+ * `@prisma-next/target-postgres/migration` so an authored Postgres
+ * `migration.ts` only needs a single dependency for its base class and
+ * its CLI entrypoint:
+ *
+ * - `Migration` — the target-owned 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`.
+ * - `MigrationCLI` — the migration-file CLI entrypoint, re-exported from
+ *   `@prisma-next/cli/migration-cli`. Loads `prisma-next.config.ts`,
+ *   assembles a `ControlStack`, and instantiates the migration class.
+ *   The migration file owns this dependency directly: pulling CLI
+ *   machinery in at script run time is acceptable because the script's
+ *   whole purpose is to be invoked from the project that owns the
+ *   config.
+ */
+const BASE_IMPORTS: readonly ImportRequirement[] = [
+  { moduleSpecifier: '@prisma-next/target-postgres/migration', symbol: 'Migration' },
+  { moduleSpecifier: '@prisma-next/target-postgres/migration', symbol: 'MigrationCLI' },
+];
+
+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),
+    '    ];',
+    '  }',
+    '}',
+    '',
+    'MigrationCLI.run(import.meta.url, M);',
+    '',
+  ].join('\n');
+}
+
+function buildImports(calls: ReadonlyArray<PostgresOpFactoryCall>): string {
+  const requirements: ImportRequirement[] = [...BASE_IMPORTS];
+  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/core/migrations/runner.ts

@@ -1,7 +1,3 @@
-import {
-  normalizeSchemaNativeType,
-  parsePostgresDefault,
-} from '@prisma-next/adapter-postgres/control';
 import type { ContractMarkerRecord } from '@prisma-next/contract/types';
 import type {
   MigrationOperationPolicy,
@@ -22,6 +18,8 @@ import { SqlQueryError } from '@prisma-next/sql-errors';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type { Result } from '@prisma-next/utils/result';
 import { ok, okVoid } from '@prisma-next/utils/result';
+import { parsePostgresDefault } from '../default-normalizer';
+import { normalizeSchemaNativeType } from '../native-type-normalizer';
 import type { PostgresPlanTargetDetails } from './planner-target-details';
 import {
   buildLedgerInsertStatement,

package/src/core/native-type-normalizer.ts

@@ -0,0 +1,49 @@
+/**
+ * Postgres native-type normalization.
+ *
+ * Lives in `target-postgres` because both the migration planner/runner (control
+ * plane) and the introspection adapter (control plane) need to normalize raw
+ * native-type strings to the same canonical form for comparison.
+ */
+
+/**
+ * Lookup map for simple prefix-based type normalization.
+ *
+ * Using a Map for O(1) lookup instead of multiple startsWith checks.
+ */
+const TYPE_PREFIX_MAP: ReadonlyMap<string, string> = new Map([
+  ['varchar', 'character varying'],
+  ['bpchar', 'character'],
+  ['varbit', 'bit varying'],
+]);
+
+/**
+ * Normalizes a Postgres schema native type to its canonical form for comparison.
+ *
+ * Uses a pre-computed lookup map for simple prefix replacements (O(1))
+ * and handles complex temporal type normalization separately.
+ */
+export function normalizeSchemaNativeType(nativeType: string): string {
+  const trimmed = nativeType.trim();
+
+  for (const [prefix, replacement] of TYPE_PREFIX_MAP) {
+    if (trimmed.startsWith(prefix)) {
+      return replacement + trimmed.slice(prefix.length);
+    }
+  }
+
+  if (trimmed.includes(' with time zone')) {
+    if (trimmed.startsWith('timestamp')) {
+      return `timestamptz${trimmed.slice(9).replace(' with time zone', '')}`;
+    }
+    if (trimmed.startsWith('time')) {
+      return `timetz${trimmed.slice(4).replace(' with time zone', '')}`;
+    }
+  }
+
+  if (trimmed.includes(' without time zone')) {
+    return trimmed.replace(' without time zone', '');
+  }
+
+  return trimmed;
+}

package/src/core/sql-utils.ts

@@ -0,0 +1,104 @@
+/**
+ * Shared SQL utility functions for the Postgres target.
+ *
+ * These functions handle safe SQL identifier and literal escaping
+ * with security validations to prevent injection and encoding issues.
+ *
+ * They live in `target-postgres` because both the control adapter (used at
+ * emit time) and the runtime adapter (used at execute time) need the same
+ * escaping/validation behavior, and the target package is the natural shared
+ * home that both adapters can depend on without crossing planes.
+ */
+
+export class SqlEscapeError extends Error {
+  constructor(
+    message: string,
+    public readonly value: string,
+    public readonly kind: 'identifier' | 'literal',
+  ) {
+    super(message);
+    this.name = 'SqlEscapeError';
+  }
+}
+
+const MAX_IDENTIFIER_LENGTH = 63;
+
+/**
+ * Validates and quotes a PostgreSQL identifier (table, column, type, schema names).
+ *
+ * Security validations:
+ * - Rejects null bytes which could cause truncation or unexpected behavior
+ * - Rejects empty identifiers
+ * - Warns on identifiers exceeding PostgreSQL's 63-character limit
+ *
+ * @throws {SqlEscapeError} If the identifier contains null bytes or is empty
+ */
+export function quoteIdentifier(identifier: string): string {
+  if (identifier.length === 0) {
+    throw new SqlEscapeError('Identifier cannot be empty', identifier, 'identifier');
+  }
+  if (identifier.includes('\0')) {
+    throw new SqlEscapeError(
+      'Identifier cannot contain null bytes',
+      identifier.replace(/\0/g, '\\0'),
+      'identifier',
+    );
+  }
+  if (identifier.length > MAX_IDENTIFIER_LENGTH) {
+    console.warn(
+      `Identifier "${identifier.slice(0, 20)}..." exceeds PostgreSQL's ${MAX_IDENTIFIER_LENGTH}-character limit and will be truncated`,
+    );
+  }
+  return `"${identifier.replace(/"/g, '""')}"`;
+}
+
+/**
+ * Escapes a string literal for safe use in SQL statements.
+ *
+ * Security validations:
+ * - Rejects null bytes which could cause truncation or unexpected behavior
+ *
+ * Note: This assumes PostgreSQL's `standard_conforming_strings` is ON (default since PG 9.1).
+ * Backslashes are treated as literal characters, not escape sequences.
+ *
+ * @throws {SqlEscapeError} If the value contains null bytes
+ */
+export function escapeLiteral(value: string): string {
+  if (value.includes('\0')) {
+    throw new SqlEscapeError(
+      'Literal value cannot contain null bytes',
+      value.replace(/\0/g, '\\0'),
+      'literal',
+    );
+  }
+  return value.replace(/'/g, "''");
+}
+
+/**
+ * Builds a qualified name (schema.object) with proper quoting.
+ */
+export function qualifyName(schemaName: string, objectName: string): string {
+  return `${quoteIdentifier(schemaName)}.${quoteIdentifier(objectName)}`;
+}
+
+/**
+ * Validates that an enum value doesn't exceed PostgreSQL's label length limit.
+ *
+ * PostgreSQL enum labels have a maximum length of NAMEDATALEN-1 (63 bytes by default).
+ * Unlike identifiers, enum labels that exceed this limit cause an error rather than
+ * silent truncation.
+ *
+ * @param value - The enum value to validate
+ * @param enumTypeName - Name of the enum type (for error messages)
+ * @throws {SqlEscapeError} If the value exceeds the maximum length
+ */
+export function validateEnumValueLength(value: string, enumTypeName: string): void {
+  if (value.length > MAX_IDENTIFIER_LENGTH) {
+    throw new SqlEscapeError(
+      `Enum value "${value.slice(0, 20)}..." for type "${enumTypeName}" exceeds PostgreSQL's ` +
+        `${MAX_IDENTIFIER_LENGTH}-character label limit`,
+      value,
+      'literal',
+    );
+  }
+}

package/src/exports/codec-ids.ts

@@ -0,0 +1 @@
+export * from '../core/codec-ids';

package/src/exports/codec-types.ts

@@ -0,0 +1,51 @@
+/**
+ * Codec type definitions for the Postgres target.
+ *
+ * This file exports type-only definitions for codec input/output types.
+ * These types are imported by generated `contract.d.ts` files for compile-time
+ * type inference.
+ *
+ * Lives in `target-postgres` because codec types describe the target's value
+ * space - both the control adapter (introspection / schema verification) and
+ * the runtime adapter (encode/decode) share the same definitions, and the
+ * target package is the natural home that both adapters depend on.
+ *
+ * Runtime codec implementations are provided by the runtime adapter's
+ * codec registry, which is built from `core/codecs.ts`.
+ */
+
+import type { JsonValue } from '@prisma-next/contract/types';
+import type { CodecTypes as CoreCodecTypes } from '../core/codecs';
+
+export type CodecTypes = CoreCodecTypes;
+
+export type { JsonValue };
+export { dataTypes } from '../core/codecs';
+
+type Branded<T, Shape extends Record<string, unknown>> = T & {
+  readonly [K in keyof Shape]: Shape[K];
+};
+
+type BrandedString<Shape extends Record<string, unknown>> = Branded<string, Shape>;
+
+export type Char<N extends number> = BrandedString<{ __charLength: N }>;
+export type Varchar<N extends number> = BrandedString<{ __varcharLength: N }>;
+export type Numeric<P extends number, S extends number | undefined = undefined> = BrandedString<{
+  __numericPrecision: P;
+  __numericScale: S;
+}>;
+export type Bit<N extends number> = BrandedString<{ __bitLength: N }>;
+export type VarBit<N extends number> = BrandedString<{ __varbitLength: N }>;
+export type Timestamp<P extends number | undefined = undefined> = BrandedString<{
+  __timestampPrecision: P;
+}>;
+export type Timestamptz<P extends number | undefined = undefined> = BrandedString<{
+  __timestamptzPrecision: P;
+}>;
+export type Time<P extends number | undefined = undefined> = BrandedString<{ __timePrecision: P }>;
+export type Timetz<P extends number | undefined = undefined> = BrandedString<{
+  __timetzPrecision: P;
+}>;
+export type Interval<P extends number | undefined = undefined> = BrandedString<{
+  __intervalPrecision: P;
+}>;

package/src/exports/codecs.ts

@@ -0,0 +1,2 @@
+export type { CodecTypes } from '../core/codecs';
+export { codecDefinitions, dataTypes } from '../core/codecs';

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/data-transform.ts

@@ -0,0 +1 @@
+export { dataTransform } from '../core/migrations/operations/data-transform';

package/src/exports/default-normalizer.ts

@@ -0,0 +1 @@
+export { parsePostgresDefault } from '../core/default-normalizer';

package/src/exports/errors.ts

@@ -0,0 +1 @@
+export { errorPostgresMigrationStackMissing } from '../core/errors';

package/src/exports/issue-planner.ts

@@ -0,0 +1 @@
+export { planIssues } from '../core/migrations/issue-planner';

package/src/exports/migration.ts

@@ -0,0 +1,46 @@
+// Re-exported so a Postgres `migration.ts` only needs the single
+// `@prisma-next/target-postgres/migration` import for its base class
+// and the CLI entrypoint, mirroring how `placeholder` is surfaced
+// here. The renderer emits the entrypoint call as
+// `MigrationCLI.run(import.meta.url, M)`.
+export { MigrationCLI } from '@prisma-next/cli/migration-cli';
+// 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/src/exports/native-type-normalizer.ts

@@ -0,0 +1 @@
+export { normalizeSchemaNativeType } from '../core/native-type-normalizer';