@prisma/orm-target-postgres 0.16.0-dev.36

package/dist/errors-kYxOQjdD-D4T3rbVp.mjs

@@ -0,0 +1,39 @@
+import { structuredError } from "@prisma/orm-framework/utils/structured-error";
+import { CliStructuredError } from "@prisma/orm-framework/errors/control";
+//#region ../../../3-targets/3-targets/postgres/dist/errors-kYxOQjdD.mjs
+function postgresError(code, message, options) {
+	return structuredError(code, message, options);
+}
+/**
+* A `PostgresMigration` operation that needs the materialized control adapter
+* — named by `operation` (e.g. `createTable`, `dropColumn`, `dataTransform`) —
+* was invoked, but the migration was constructed without a `ControlStack`.
+* Concrete authoring usage always goes through the migration CLI entrypoint,
+* which assembles a stack from the loaded `prisma-next.config.ts`; reaching this
+* error means a test fixture or ad-hoc consumer instantiated `PostgresMigration`
+* with the no-arg form (legal for `operations` / `describe` introspection only).
+*
+* The `operation` argument is required so every throw site names the operation
+* that actually failed; a new operation cannot inherit a misattributed message.
+*
+* Distinct from `MIGRATION.UNFILLED_PLACEHOLDER` (placeholder not filled)
+* and `MIGRATION.DATA_TRANSFORM_CONTRACT_MISMATCH` (data-transform query
+* plan against wrong contract) because the missing input is the stack
+* itself, not the per-operation contract.
+*
+* Lives in `@internal/target-postgres/errors` rather than the shared
+* framework migration errors module because the failure is target-specific:
+* the contract it talks about (`PostgresMigration`, the Postgres control
+* adapter, the Postgres-target stack) only exists in this package.
+*/
+function errorPostgresMigrationStackMissing(operation) {
+	return new CliStructuredError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `PostgresMigration.${operation} requires a control adapter`, {
+		why: `PostgresMigration.${operation} was invoked on an instance constructed without a ControlStack, so the stored controlAdapter is undefined and the operation cannot lower its plan.`,
+		fix: "Construct the migration via the migration CLI entrypoint (which assembles a ControlStack from the loaded prisma-next.config.ts), or pass a ControlStack containing a Postgres adapter to the migration constructor in test fixtures.",
+		meta: { operation }
+	});
+}
+//#endregion
+export { postgresError as n, errorPostgresMigrationStackMissing as t };
+
+//# sourceMappingURL=errors-kYxOQjdD-D4T3rbVp.mjs.map

package/dist/errors-kYxOQjdD-D4T3rbVp.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-kYxOQjdD-D4T3rbVp.mjs","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/errors-kYxOQjdD.mjs"],"sourcesContent":["import { structuredError } from \"@internal/utils/structured-error\";\nimport { CliStructuredError } from \"@internal/errors/control\";\n//#region src/core/errors.ts\nfunction postgresError(code, message, options) {\n\treturn structuredError(code, message, options);\n}\n/**\n* A `PostgresMigration` operation that needs the materialized control adapter\n* — named by `operation` (e.g. `createTable`, `dropColumn`, `dataTransform`) —\n* was invoked, but the migration was constructed without a `ControlStack`.\n* Concrete authoring usage always goes through the migration CLI entrypoint,\n* which assembles a stack from the loaded `prisma-next.config.ts`; reaching this\n* error means a test fixture or ad-hoc consumer instantiated `PostgresMigration`\n* with the no-arg form (legal for `operations` / `describe` introspection only).\n*\n* The `operation` argument is required so every throw site names the operation\n* that actually failed; a new operation cannot inherit a misattributed message.\n*\n* Distinct from `MIGRATION.UNFILLED_PLACEHOLDER` (placeholder not filled)\n* and `MIGRATION.DATA_TRANSFORM_CONTRACT_MISMATCH` (data-transform query\n* plan against wrong contract) because the missing input is the stack\n* itself, not the per-operation contract.\n*\n* Lives in `@internal/target-postgres/errors` rather than the shared\n* framework migration errors module because the failure is target-specific:\n* the contract it talks about (`PostgresMigration`, the Postgres control\n* adapter, the Postgres-target stack) only exists in this package.\n*/\nfunction errorPostgresMigrationStackMissing(operation) {\n\treturn new CliStructuredError(\"MIGRATION.POSTGRES_CONTROL_STACK_MISSING\", `PostgresMigration.${operation} requires a control adapter`, {\n\t\twhy: `PostgresMigration.${operation} was invoked on an instance constructed without a ControlStack, so the stored controlAdapter is undefined and the operation cannot lower its plan.`,\n\t\tfix: \"Construct the migration via the migration CLI entrypoint (which assembles a ControlStack from the loaded prisma-next.config.ts), or pass a ControlStack containing a Postgres adapter to the migration constructor in test fixtures.\",\n\t\tmeta: { operation }\n\t});\n}\n//#endregion\nexport { postgresError as n, errorPostgresMigrationStackMissing as t };\n\n//# sourceMappingURL=errors-kYxOQjdD.mjs.map"],"mappings":";;;AAGA,SAAS,cAAc,MAAM,SAAS,SAAS;CAC9C,OAAO,gBAAgB,MAAM,SAAS,OAAO;AAC9C;;;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAS,mCAAmC,WAAW;CACtD,OAAO,IAAI,mBAAmB,4CAA4C,qBAAqB,UAAU,8BAA8B;EACtI,KAAK,qBAAqB,UAAU;EACpC,KAAK;EACL,MAAM,EAAE,UAAU;CACnB,CAAC;AACF"}

package/dist/issue-planner-jkY6p-Ca.d.mts

@@ -0,0 +1,105 @@
+import { j as PostgresOpFactoryCall } from "./op-factory-call-jd4cgfjA-CyNT4YVn.mjs";
+import { SqlStorage, StorageTypeInstance } from "@prisma/orm-family-sql/contract/types";
+import { DiffableNode, SchemaDiffIssue } from "@prisma/orm-framework/components/control";
+import { CodecControlHooks, MigrationOperationPolicy, SqlPlannerConflict } from "@prisma/orm-family-sql/family/control";
+import { SqlSchemaIR } from "@prisma/orm-family-sql/schema-ir/types";
+import { Result } from "@prisma/orm-framework/utils/result";
+import { Contract } from "@prisma/orm-framework/contract/types";
+import { TargetBoundComponentDescriptor } from "@prisma/orm-framework/components/components";
+//#region ../../../3-targets/3-targets/postgres/dist/issue-planner.d.mts
+//#region src/core/migrations/planner-strategies.d.ts
+/**
+ * Context passed to each migration strategy.
+ *
+ * Strategies read the source (`fromContract`), target (`toContract`), current
+ * database state (`schema`), operation policy (`policy`), and component list
+ * (`frameworkComponents`) to make planning decisions. `fromContract` is null
+ * when no prior contract is available (e.g. `db update`, where the current
+ * DB state is approximated via `schema`).
+ */
+interface StrategyContext {
+  readonly toContract: Contract<SqlStorage>;
+  readonly fromContract: Contract<SqlStorage> | null;
+  readonly schemaName: string;
+  readonly codecHooks: ReadonlyMap<string, CodecControlHooks>;
+  readonly storageTypes: Readonly<Record<string, StorageTypeInstance>>;
+  readonly schema: SqlSchemaIR;
+  readonly policy: MigrationOperationPolicy;
+  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+}
+/**
+ * Consumes node-typed diff issues (`SchemaDiffIssue`, from the one differ —
+ * `buildPostgresPlanDiff`), reading the issue's node pair for structural
+ * decisions and resolving column DDL from the node's `codecRef`. The
+ * retained subsystems (codec type-operations, the NOT-NULL temp-default
+ * backfill) keep reading the contract via `StrategyContext`.
+ */
+type CallMigrationStrategy = (issues: readonly SchemaDiffIssue[], context: StrategyContext) => {
+  kind: 'match';
+  issues: readonly SchemaDiffIssue[];
+  calls: readonly PostgresOpFactoryCall[];
+  /**
+   * `true` for strategies that emit cohesive sequential recipes whose
+   * calls must stay contiguous and in the returned order — e.g.
+   * `notNullBackfillCallStrategy` (addColumn → dataTransform → setNotNull).
+   * Defaults to `false`, which lets `planIssues` hoist individual calls
+   * into their DDL sequencing bucket.
+   */
+  recipe?: boolean;
+} | {
+  kind: 'no_match';
+};
+//#endregion
+//#region src/core/migrations/issue-planner.d.ts
+interface IssuePlannerValue {
+  readonly calls: readonly PostgresOpFactoryCall[];
+}
+/**
+ * The generic differ is total: a missing/extra table (or column) emits an
+ * issue for itself AND for every node in its subtree. `CreateTable`/`DropTable`
+ * and `AddColumn`/`DropColumn` already account for the whole subtree, so the
+ * nested issues are redundant — coalescing drops any issue whose path is a
+ * strict descendant of a `not-found`/`not-expected` issue's path. Run over the
+ * relational subset ONLY (policy issues and synthesized namespace issues are
+ * handled on their own paths, never coalesced against tables).
+ */
+declare function coalesceSubtreeIssues<TNode extends DiffableNode = DiffableNode>(issues: readonly SchemaDiffIssue<TNode>[]): readonly SchemaDiffIssue<TNode>[];
+interface IssuePlannerOptions {
+  readonly issues: readonly SchemaDiffIssue[];
+  readonly toContract: Contract<SqlStorage>;
+  readonly fromContract: Contract<SqlStorage> | null;
+  readonly schemaName: string;
+  readonly codecHooks: ReadonlyMap<string, CodecControlHooks>;
+  readonly storageTypes: Readonly<Record<string, StorageTypeInstance>>;
+  /**
+   * Current database schema IR. Strategies read this to detect whether a
+   * structure already exists (e.g. `buildSchemaLookupMap` for shared-temp-
+   * default safety, extension dependency checks). Defaults to an empty schema
+   * when omitted so the planner can still run over "fresh DB" contract
+   * snapshots.
+   */
+  readonly schema?: SqlSchemaIR;
+  /**
+   * Operation-class policy. `planIssues` filters calls whose `operationClass`
+   * is not in `policy.allowedOperationClasses` and surfaces them as conflicts
+   * instead of emitting disallowed DDL. Defaults to additive-only.
+   */
+  readonly policy?: MigrationOperationPolicy;
+  /**
+   * Framework components participating in this composition. Available to
+   * future strategies that may consult component metadata at plan time.
+   */
+  readonly frameworkComponents?: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+  readonly strategies?: readonly CallMigrationStrategy[];
+}
+/**
+ * Runs the ordered strategy list over the node-typed diff issues, maps
+ * leftover issues via {@link mapNodeIssueToCall}, applies operation-class
+ * policy gating, and buckets calls into the fixed DDL emission order (dep →
+ * drop → table → column → recipe → alter → primaryKey → unique → index →
+ * foreignKey).
+ */
+declare function planIssues(options: IssuePlannerOptions): Result<IssuePlannerValue, readonly SqlPlannerConflict[]>;
+//#endregion
+export { planIssues as n, coalesceSubtreeIssues as t };
+//# sourceMappingURL=issue-planner-jkY6p-Ca.d.mts.map

package/dist/issue-planner-jkY6p-Ca.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"issue-planner-jkY6p-Ca.d.mts","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/issue-planner.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;UAkBU;WACC,YAAY,SAAS;WACrB,cAAc,SAAS;WACvB;WACA,YAAY,oBAAoB;WAChC,cAAc,SAAS,eAAe;WACtC,QAAQ;WACR,QAAQ;WACR,qBAAqB,cAAc;;;;;;;;;KASzC,yBAAyB,iBAAiB,mBAAmB,SAAS;EACzE;EACA,iBAAiB;EACjB,gBAAgB;;;;;;;;EAQhB;;EAEA;;;;UAIQ;WACC,gBAAgB;;;;;;;;;;;iBAWV,sBAAsB,cAAc,eAAe,cAAc,iBAAiB,gBAAgB,oBAAoB,gBAAgB;UAC7I;WACC,iBAAiB;WACjB,YAAY,SAAS;WACrB,cAAc,SAAS;WACvB;WACA,YAAY,oBAAoB;WAChC,cAAc,SAAS,eAAe;;;;;;;;WAQtC,SAAS;;;;;;WAMT,SAAS;;;;;WAKT,sBAAsB,cAAc;WACpC,sBAAsB;;;;;;;;;iBAShB,WAAW,SAAS,sBAAsB,OAAO,4BAA4B"}

package/dist/migration-CBSAPE8S.d.mts

@@ -0,0 +1,25 @@
+import "./data-transform-Ck5FbyNO-BNE7QlAo.mjs";
+import { A as Op$1 } from "./op-factory-call-jd4cgfjA-CyNT4YVn.mjs";
+import "./postgres-migration-CDJj7CvD-Bsqs_fVo.mjs";
+import { checkExpression, col as col$1, fn as fn$1, foreignKey, lit as lit$1, primaryKey, unique } from "@prisma/orm-family-sql/relational-core/contract-free";
+import { placeholder } from "@prisma/orm-framework/errors/migration";
+import { MigrationCLI } from "@prisma/orm-toolchain/cli/migration-cli";
+//#region ../../../3-targets/3-targets/postgres/dist/migration.d.mts
+//#region src/core/migrations/operations/dependencies.d.ts
+declare function createExtension(extensionName: string): Op$1;
+//#endregion
+//#region src/core/migrations/operations/raw.d.ts
+/**
+ * Identity factory for an already-materialized `SqlMigrationPlanOperation`.
+ *
+ * The planner uses this via `liftOpToCall` to carry ops produced by SQL
+ * family methods, codec control hooks, and component database dependencies
+ * alongside migration IR without reverse-engineering them. Users writing
+ * raw migrations can pass a full op shape directly — typically built by
+ * composing SQL family helpers — to author a migration that bypasses the
+ * structured call classes.
+ */
+declare function rawSql(op: Op$1): Op$1;
+//#endregion
+export { fn$1 as a, placeholder as c, unique as d, createExtension as i, primaryKey as l, checkExpression as n, foreignKey as o, col$1 as r, lit$1 as s, MigrationCLI as t, rawSql as u };
+//# sourceMappingURL=migration-CBSAPE8S.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"migration-CBSAPE8S.d.mts","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/migration.d.mts"],"mappings":";;;;;;;;iBAQiB,gBAAgB,wBAAwB;;;;;;;;;;;;;iBAaxC,OAAO,IAAI,OAAK"}

package/dist/migration-PTHAY9Cv.mjs

@@ -0,0 +1,21 @@
+import { checkExpression, col as col$1, fn as fn$1, foreignKey, lit as lit$1, primaryKey, unique } from "@prisma/orm-family-sql/relational-core/contract-free";
+import { placeholder } from "@prisma/orm-framework/errors/migration";
+import { MigrationCLI } from "@prisma/orm-toolchain/cli/migration-cli";
+//#region ../../../3-targets/3-targets/postgres/dist/migration.mjs
+/**
+* Identity factory for an already-materialized `SqlMigrationPlanOperation`.
+*
+* The planner uses this via `liftOpToCall` to carry ops produced by SQL
+* family methods, codec control hooks, and component database dependencies
+* alongside migration IR without reverse-engineering them. Users writing
+* raw migrations can pass a full op shape directly — typically built by
+* composing SQL family helpers — to author a migration that bypasses the
+* structured call classes.
+*/
+function rawSql(op) {
+	return op;
+}
+//#endregion
+export { foreignKey as a, primaryKey as c, fn$1 as i, rawSql as l, checkExpression as n, lit$1 as o, col$1 as r, placeholder as s, MigrationCLI as t, unique as u };
+
+//# sourceMappingURL=migration-PTHAY9Cv.mjs.map

package/dist/migration-PTHAY9Cv.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration-PTHAY9Cv.mjs","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/migration.mjs"],"sourcesContent":["import { F as createExtension } from \"./op-factory-call-DifL68KT.mjs\";\nimport { t as dataTransform } from \"./data-transform-ChZzy2dP.mjs\";\nimport { t as PostgresMigration } from \"./postgres-migration-CJshdIZn.mjs\";\nimport { checkExpression, col, fn, foreignKey, lit, primaryKey, unique } from \"@internal/sql-relational-core/contract-free\";\nimport { placeholder } from \"@internal/errors/migration\";\nimport { MigrationCLI } from \"@internal/cli/migration-cli\";\n//#region src/core/migrations/operations/raw.ts\n/**\n* Identity factory for an already-materialized `SqlMigrationPlanOperation`.\n*\n* The planner uses this via `liftOpToCall` to carry ops produced by SQL\n* family methods, codec control hooks, and component database dependencies\n* alongside migration IR without reverse-engineering them. Users writing\n* raw migrations can pass a full op shape directly — typically built by\n* composing SQL family helpers — to author a migration that bypasses the\n* structured call classes.\n*/\nfunction rawSql(op) {\n\treturn op;\n}\n//#endregion\nexport { PostgresMigration as Migration, MigrationCLI, checkExpression, col, createExtension, dataTransform, fn, foreignKey, lit, placeholder, primaryKey, rawSql, unique };\n\n//# sourceMappingURL=migration.mjs.map"],"mappings":";;;;;;;;;;;;;;AAiBA,SAAS,OAAO,IAAI;CACnB,OAAO;AACR"}

package/dist/namespace-ids-xtp_ZY86-Cpp8PTxD.mjs

@@ -0,0 +1,7 @@
+//#region ../../../3-targets/3-targets/postgres/dist/namespace-ids-xtp_ZY86.mjs
+/** Postgres's default schema; `postgresTargetDescriptorMeta.defaultNamespaceId` is this value. */
+const DEFAULT_NAMESPACE_ID = "public";
+//#endregion
+export { DEFAULT_NAMESPACE_ID as t };
+
+//# sourceMappingURL=namespace-ids-xtp_ZY86-Cpp8PTxD.mjs.map

package/dist/namespace-ids-xtp_ZY86-Cpp8PTxD.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"namespace-ids-xtp_ZY86-Cpp8PTxD.mjs","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/namespace-ids-xtp_ZY86.mjs"],"sourcesContent":["//#region src/core/namespace-ids.ts\n/** Postgres's default schema; `postgresTargetDescriptorMeta.defaultNamespaceId` is this value. */\nconst DEFAULT_NAMESPACE_ID = \"public\";\n//#endregion\nexport { DEFAULT_NAMESPACE_ID as t };\n\n//# sourceMappingURL=namespace-ids-xtp_ZY86.mjs.map"],"mappings":";;AAEA,MAAM,uBAAuB"}

package/dist/native-type-normalizer-DqJlOTeX.d.mts

@@ -0,0 +1,19 @@
+//#region ../../../3-targets/3-targets/postgres/dist/native-type-normalizer.d.mts
+//#region src/core/native-type-normalizer.d.ts
+/**
+ * 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.
+ */
+/**
+ * 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.
+ */
+declare function normalizeSchemaNativeType(nativeType: string): string;
+//#endregion
+export { normalizeSchemaNativeType as t };
+//# sourceMappingURL=native-type-normalizer-DqJlOTeX.d.mts.map

package/dist/native-type-normalizer-DqJlOTeX.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-type-normalizer-DqJlOTeX.d.mts","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/native-type-normalizer.d.mts"],"mappings":";;;;;;;;;;;;;;;iBAciB,0BAA0B"}

package/dist/native-type-normalizer-yvd3tqv-.mjs

@@ -0,0 +1,38 @@
+//#region ../../../3-targets/3-targets/postgres/dist/native-type-normalizer.mjs
+/**
+* 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 = /* @__PURE__ */ 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.
+*/
+function normalizeSchemaNativeType(nativeType) {
+	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;
+}
+//#endregion
+export { normalizeSchemaNativeType as t };
+
+//# sourceMappingURL=native-type-normalizer-yvd3tqv-.mjs.map

package/dist/native-type-normalizer-yvd3tqv-.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-type-normalizer-yvd3tqv-.mjs","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/native-type-normalizer.mjs"],"sourcesContent":["//#region src/core/native-type-normalizer.ts\n/**\n* Postgres native-type normalization.\n*\n* Lives in `target-postgres` because both the migration planner/runner (control\n* plane) and the introspection adapter (control plane) need to normalize raw\n* native-type strings to the same canonical form for comparison.\n*/\n/**\n* Lookup map for simple prefix-based type normalization.\n*\n* Using a Map for O(1) lookup instead of multiple startsWith checks.\n*/\nconst TYPE_PREFIX_MAP = /* @__PURE__ */ new Map([\n\t[\"varchar\", \"character varying\"],\n\t[\"bpchar\", \"character\"],\n\t[\"varbit\", \"bit varying\"]\n]);\n/**\n* Normalizes a Postgres schema native type to its canonical form for comparison.\n*\n* Uses a pre-computed lookup map for simple prefix replacements (O(1))\n* and handles complex temporal type normalization separately.\n*/\nfunction normalizeSchemaNativeType(nativeType) {\n\tconst trimmed = nativeType.trim();\n\tfor (const [prefix, replacement] of TYPE_PREFIX_MAP) if (trimmed.startsWith(prefix)) return replacement + trimmed.slice(prefix.length);\n\tif (trimmed.includes(\" with time zone\")) {\n\t\tif (trimmed.startsWith(\"timestamp\")) return `timestamptz${trimmed.slice(9).replace(\" with time zone\", \"\")}`;\n\t\tif (trimmed.startsWith(\"time\")) return `timetz${trimmed.slice(4).replace(\" with time zone\", \"\")}`;\n\t}\n\tif (trimmed.includes(\" without time zone\")) return trimmed.replace(\" without time zone\", \"\");\n\treturn trimmed;\n}\n//#endregion\nexport { normalizeSchemaNativeType };\n\n//# sourceMappingURL=native-type-normalizer.mjs.map"],"mappings":";;;;;;;;;;;;;AAaA,MAAM,kCAAkC,IAAI,IAAI;CAC/C,CAAC,WAAW,mBAAmB;CAC/B,CAAC,UAAU,WAAW;CACtB,CAAC,UAAU,aAAa;AACzB,CAAC;;;;;;;AAOD,SAAS,0BAA0B,YAAY;CAC9C,MAAM,UAAU,WAAW,KAAK;CAChC,KAAK,MAAM,CAAC,QAAQ,gBAAgB,iBAAiB,IAAI,QAAQ,WAAW,MAAM,GAAG,OAAO,cAAc,QAAQ,MAAM,OAAO,MAAM;CACrI,IAAI,QAAQ,SAAS,iBAAiB,GAAG;EACxC,IAAI,QAAQ,WAAW,WAAW,GAAG,OAAO,cAAc,QAAQ,MAAM,CAAC,CAAC,CAAC,QAAQ,mBAAmB,EAAE;EACxG,IAAI,QAAQ,WAAW,MAAM,GAAG,OAAO,SAAS,QAAQ,MAAM,CAAC,CAAC,CAAC,QAAQ,mBAAmB,EAAE;CAC/F;CACA,IAAI,QAAQ,SAAS,oBAAoB,GAAG,OAAO,QAAQ,QAAQ,sBAAsB,EAAE;CAC3F,OAAO;AACR"}

package/dist/nodes-BU-V-aZA-RqwPH68u.d.mts

@@ -0,0 +1,235 @@
+import { r as RlsPolicyOperation } from "./canonicalize-CQlxSR4D-MnrT5gtW.mjs";
+import { DdlColumn, DdlNode, DdlTableConstraint } from "@prisma/orm-family-sql/relational-core/ast";
+//#region ../../../3-targets/3-targets/postgres/dist/nodes-BU-V-aZA.d.mts
+//#region src/core/ddl/nodes.d.ts
+interface AlterTableActionVisitor<R> {
+  addColumn(action: AddColumnAction): R;
+  dropDefault(action: DropDefaultAction): R;
+}
+declare abstract class AlterTableAction {
+  abstract readonly kind: string;
+  abstract accept<R>(visitor: AlterTableActionVisitor<R>): R;
+}
+declare class AddColumnAction extends AlterTableAction {
+  readonly kind: "add-column";
+  readonly column: DdlColumn;
+  constructor(column: DdlColumn);
+  accept<R>(visitor: AlterTableActionVisitor<R>): R;
+}
+declare class DropDefaultAction extends AlterTableAction {
+  readonly kind: "drop-default";
+  readonly columnName: string;
+  constructor(columnName: string);
+  accept<R>(visitor: AlterTableActionVisitor<R>): R;
+}
+/**
+ * The set of ALTER TABLE subactions currently expressible as typed DDL.
+ *
+ * The remaining actions — SetDefault, SetNotNull, DropNotNull,
+ * AlterColumnType — are still emitted as raw SQL by `operations/columns.ts`
+ * and join this union as they are converted to typed DDL. Until then it is
+ * intentionally partial: only the ALTER subactions used by the
+ * already-converted ops (AddColumn, DropDefault) appear here.
+ */
+type AnyAlterTableAction = AddColumnAction | DropDefaultAction;
+interface PostgresDdlVisitor<R> {
+  createTable(node: PostgresCreateTable): R;
+  createSchema(node: PostgresCreateSchema): R;
+  createType(node: PostgresCreateType): R;
+  dropType(node: PostgresDropType): R;
+  alterTable(node: PostgresAlterTable): R;
+  createPolicy(node: PostgresCreatePolicy): R;
+  dropPolicy(node: PostgresDropPolicy): R;
+  alterPolicyRename(node: PostgresAlterPolicyRename): R;
+  createIndex(node: PostgresCreateIndex): R;
+  dropIndex(node: PostgresDropIndex): R;
+  alterIndexRename(node: PostgresAlterIndexRename): R;
+  disableRowLevelSecurity(node: PostgresDisableRowLevelSecurity): R;
+}
+declare abstract class PostgresDdlNode extends DdlNode {
+  abstract accept<R>(visitor: PostgresDdlVisitor<R>): R;
+}
+declare class PostgresCreateTable extends PostgresDdlNode {
+  readonly kind: "create-table";
+  readonly table: string;
+  readonly schema: string | undefined;
+  readonly ifNotExists: boolean | undefined;
+  readonly columns: ReadonlyArray<DdlColumn>;
+  readonly constraints: ReadonlyArray<DdlTableConstraint> | undefined;
+  constructor(options: {
+    readonly table: string;
+    readonly schema?: string;
+    readonly ifNotExists?: boolean;
+    readonly columns: readonly DdlColumn[];
+    readonly constraints?: readonly DdlTableConstraint[];
+  });
+  accept<R>(visitor: PostgresDdlVisitor<R>): R;
+}
+declare class PostgresCreateSchema extends PostgresDdlNode {
+  readonly kind: "create-schema";
+  readonly schema: string;
+  readonly ifNotExists: boolean | undefined;
+  constructor(options: {
+    readonly schema: string;
+    readonly ifNotExists?: boolean;
+  });
+  accept<R>(visitor: PostgresDdlVisitor<R>): R;
+}
+declare class PostgresCreateType extends PostgresDdlNode {
+  readonly kind: "create-type";
+  readonly schema: string | undefined;
+  readonly name: string;
+  readonly values: ReadonlyArray<string>;
+  constructor(options: {
+    readonly schema?: string;
+    readonly name: string;
+    readonly values: readonly string[];
+  });
+  accept<R>(visitor: PostgresDdlVisitor<R>): R;
+}
+declare class PostgresDropType extends PostgresDdlNode {
+  readonly kind: "drop-type";
+  readonly schema: string | undefined;
+  readonly name: string;
+  constructor(options: {
+    readonly schema?: string;
+    readonly name: string;
+  });
+  accept<R>(visitor: PostgresDdlVisitor<R>): R;
+}
+declare class PostgresAlterTable extends PostgresDdlNode {
+  readonly kind: "alter-table";
+  readonly table: string;
+  readonly schema: string | undefined;
+  readonly actions: ReadonlyArray<AnyAlterTableAction>;
+  constructor(options: {
+    readonly table: string;
+    readonly schema?: string;
+    readonly actions: readonly AnyAlterTableAction[];
+  });
+  accept<R>(visitor: PostgresDdlVisitor<R>): R;
+}
+declare class PostgresCreatePolicy extends PostgresDdlNode {
+  readonly kind: "create-policy";
+  readonly schema: string;
+  readonly table: string;
+  readonly name: string;
+  readonly permissive: boolean;
+  readonly operation: RlsPolicyOperation;
+  readonly roles: ReadonlyArray<string>;
+  readonly using: string | undefined;
+  readonly withCheck: string | undefined;
+  constructor(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly name: string;
+    readonly permissive: boolean;
+    readonly operation: RlsPolicyOperation;
+    readonly roles: readonly string[];
+    readonly using?: string;
+    readonly withCheck?: string;
+  });
+  accept<R>(visitor: PostgresDdlVisitor<R>): R;
+}
+declare class PostgresDropPolicy extends PostgresDdlNode {
+  readonly kind: "drop-policy";
+  readonly schema: string;
+  readonly table: string;
+  readonly name: string;
+  constructor(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly name: string;
+  });
+  accept<R>(visitor: PostgresDdlVisitor<R>): R;
+}
+declare class PostgresAlterPolicyRename extends PostgresDdlNode {
+  readonly kind: "alter-policy-rename";
+  readonly schema: string;
+  readonly table: string;
+  readonly name: string;
+  readonly newName: string;
+  constructor(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly name: string;
+    readonly newName: string;
+  });
+  accept<R>(visitor: PostgresDdlVisitor<R>): R;
+}
+/**
+ * The element list between the parens of CREATE INDEX: either a column
+ * tuple (each identifier quoted by the renderer) or one opaque expression
+ * string covering the entire list, inserted verbatim — the same opaque-SQL
+ * stance as RLS policy predicates (ADR 234).
+ */
+type DdlIndexElements = {
+  readonly columns: readonly string[];
+} | {
+  readonly expression: string;
+};
+declare class PostgresCreateIndex extends PostgresDdlNode {
+  readonly kind: "create-index";
+  /** Absent ⇔ unqualified (the unbound namespace — `search_path` decides). */
+  readonly schema: string | undefined;
+  readonly table: string;
+  readonly name: string;
+  readonly unique: boolean;
+  readonly elements: DdlIndexElements;
+  readonly type: string | undefined;
+  readonly options: Record<string, unknown> | undefined;
+  /**
+   * Partial-index predicate (WHERE body, without the keyword). Inserted
+   * verbatim, never quoted or escaped.
+   */
+  readonly where: string | undefined;
+  constructor(options: {
+    readonly schema: string | undefined;
+    readonly table: string;
+    readonly name: string;
+    readonly unique: boolean;
+    readonly elements: DdlIndexElements;
+    readonly type: string | undefined;
+    readonly options: Record<string, unknown> | undefined;
+    readonly where: string | undefined;
+  });
+  accept<R>(visitor: PostgresDdlVisitor<R>): R;
+}
+declare class PostgresDropIndex extends PostgresDdlNode {
+  readonly kind: "drop-index";
+  /** Absent ⇔ unqualified (the unbound namespace). */
+  readonly schema: string | undefined;
+  readonly name: string;
+  constructor(options: {
+    readonly schema: string | undefined;
+    readonly name: string;
+  });
+  accept<R>(visitor: PostgresDdlVisitor<R>): R;
+}
+declare class PostgresAlterIndexRename extends PostgresDdlNode {
+  readonly kind: "alter-index-rename";
+  /** Absent ⇔ unqualified (the unbound namespace). */
+  readonly schema: string | undefined;
+  readonly from: string;
+  readonly to: string;
+  constructor(options: {
+    readonly schema: string | undefined;
+    readonly from: string;
+    readonly to: string;
+  });
+  accept<R>(visitor: PostgresDdlVisitor<R>): R;
+}
+declare class PostgresDisableRowLevelSecurity extends PostgresDdlNode {
+  readonly kind: "disable-row-level-security";
+  readonly schema: string;
+  readonly table: string;
+  constructor(options: {
+    readonly schema: string;
+    readonly table: string;
+  });
+  accept<R>(visitor: PostgresDdlVisitor<R>): R;
+}
+type AnyPostgresDdlNode = PostgresCreateTable | PostgresCreateSchema | PostgresCreateType | PostgresDropType | PostgresAlterTable | PostgresCreatePolicy | PostgresDropPolicy | PostgresAlterPolicyRename | PostgresCreateIndex | PostgresDropIndex | PostgresAlterIndexRename | PostgresDisableRowLevelSecurity;
+//#endregion
+export { PostgresDisableRowLevelSecurity as _, DdlIndexElements as a, PostgresDropType as b, PostgresAlterPolicyRename as c, PostgresCreatePolicy as d, PostgresCreateSchema as f, PostgresDdlVisitor as g, PostgresDdlNode as h, AnyPostgresDdlNode as i, PostgresAlterTable as l, PostgresCreateType as m, AlterTableActionVisitor as n, DropDefaultAction as o, PostgresCreateTable as p, AnyAlterTableAction as r, PostgresAlterIndexRename as s, AddColumnAction as t, PostgresCreateIndex as u, PostgresDropIndex as v, PostgresDropPolicy as y };
+//# sourceMappingURL=nodes-BU-V-aZA-RqwPH68u.d.mts.map

package/dist/nodes-BU-V-aZA-RqwPH68u.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodes-BU-V-aZA-RqwPH68u.d.mts","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/nodes-BU-V-aZA.d.mts"],"mappings":"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"}