@prisma-next/target-postgres 0.4.0-dev.6 → 0.4.0-dev.7

package/dist/control.mjs

@@ -4,13 +4,15 @@ import { LiteralExpr, SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, S
 import { ifDefined } from "@prisma-next/utils/defined";
 import { type } from "arktype";
 import { arraysEqual, verifySqlSchema } from "@prisma-next/family-sql/schema-verify";
-import { collectInitDependencies, contractToSchemaIR, createMigrationPlan, extractCodecControlHooks, plannerFailure, plannerSuccess, runnerFailure, runnerSuccess } from "@prisma-next/family-sql/control";
+import { collectInitDependencies, contractToSchemaIR, createMigrationPlan, extractCodecControlHooks, plannerFailure, runnerFailure, runnerSuccess } from "@prisma-next/family-sql/control";
 import { MigrationDescriptorArraySchema } from "@prisma-next/family-sql/operation-descriptors";
 import { sql } from "@prisma-next/sql-builder/runtime";
 import { notOk, ok, okVoid } from "@prisma-next/utils/result";
 import { lowerSqlPlan } from "@prisma-next/sql-runtime";
+import { errorPlanDoesNotSupportAuthoringSurface } from "@prisma-next/errors/migration";
 import { defaultIndexName } from "@prisma-next/sql-schema-ir/naming";
 import { invariant } from "@prisma-next/utils/assertions";
+import { relative } from "pathe";
 import { readMarker } from "@prisma-next/family-sql/verify";
 import { SqlQueryError } from "@prisma-next/sql-errors";
 
@@ -4299,6 +4301,94 @@ function hasForeignKey(lookup, fk) {
 	return lookup.fkKeys.has(`${fk.columns.join(",")}|${fk.references.table}|${fk.references.columns.join(",")}`);
 }
 
+//#endregion
+//#region src/core/migrations/scaffolding.ts
+function serializeQueryInput(input) {
+	if (typeof input === "boolean") return String(input);
+	if (typeof input === "symbol") return "TODO /* fill in using db.sql.from(...) */";
+	if (input === null || input === void 0) return "null";
+	if (Array.isArray(input)) {
+		if (input.length === 0) return "[]";
+		if (input.every((item) => typeof item === "symbol")) return "[TODO /* fill in using db.sql.from(...) */]";
+		return `[${input.map(serializeQueryInput).join(", ")}]`;
+	}
+	return JSON.stringify(input);
+}
+function renderDescriptor(desc) {
+	switch (desc.kind) {
+		case "createTable": return `createTable(${JSON.stringify(desc["table"])})`;
+		case "dropTable": return `dropTable(${JSON.stringify(desc["table"])})`;
+		case "addColumn": {
+			const args = [JSON.stringify(desc["table"]), JSON.stringify(desc["column"])];
+			if (desc["overrides"]) args.push(JSON.stringify(desc["overrides"]));
+			return `addColumn(${args.join(", ")})`;
+		}
+		case "dropColumn": return `dropColumn(${JSON.stringify(desc["table"])}, ${JSON.stringify(desc["column"])})`;
+		case "alterColumnType": {
+			const opts = {};
+			if (desc["using"]) opts["using"] = desc["using"];
+			if (desc["toType"]) opts["toType"] = desc["toType"];
+			return Object.keys(opts).length > 0 ? `alterColumnType(${JSON.stringify(desc["table"])}, ${JSON.stringify(desc["column"])}, ${JSON.stringify(opts)})` : `alterColumnType(${JSON.stringify(desc["table"])}, ${JSON.stringify(desc["column"])})`;
+		}
+		case "setNotNull": return `setNotNull(${JSON.stringify(desc["table"])}, ${JSON.stringify(desc["column"])})`;
+		case "dropNotNull": return `dropNotNull(${JSON.stringify(desc["table"])}, ${JSON.stringify(desc["column"])})`;
+		case "setDefault": return `setDefault(${JSON.stringify(desc["table"])}, ${JSON.stringify(desc["column"])})`;
+		case "dropDefault": return `dropDefault(${JSON.stringify(desc["table"])}, ${JSON.stringify(desc["column"])})`;
+		case "addPrimaryKey": return `addPrimaryKey(${JSON.stringify(desc["table"])})`;
+		case "addUnique": return `addUnique(${JSON.stringify(desc["table"])}, ${JSON.stringify(desc["columns"])})`;
+		case "addForeignKey": return `addForeignKey(${JSON.stringify(desc["table"])}, ${JSON.stringify(desc["columns"])})`;
+		case "dropConstraint": return `dropConstraint(${JSON.stringify(desc["table"])}, ${JSON.stringify(desc["constraintName"])})`;
+		case "createIndex": return `createIndex(${JSON.stringify(desc["table"])}, ${JSON.stringify(desc["columns"])})`;
+		case "dropIndex": return `dropIndex(${JSON.stringify(desc["table"])}, ${JSON.stringify(desc["indexName"])})`;
+		case "createEnumType": return desc["values"] ? `createEnumType(${JSON.stringify(desc["typeName"])}, ${JSON.stringify(desc["values"])})` : `createEnumType(${JSON.stringify(desc["typeName"])})`;
+		case "addEnumValues": return `addEnumValues(${JSON.stringify(desc["typeName"])}, ${JSON.stringify(desc["values"])})`;
+		case "dropEnumType": return `dropEnumType(${JSON.stringify(desc["typeName"])})`;
+		case "renameType": return `renameType(${JSON.stringify(desc["fromName"])}, ${JSON.stringify(desc["toName"])})`;
+		case "createDependency": return `createDependency(${JSON.stringify(desc["dependencyId"])})`;
+		case "dataTransform": return `dataTransform(${JSON.stringify(desc["name"])}, {\n    check: ${serializeQueryInput(desc["check"])},\n    run: ${serializeQueryInput(desc["run"])},\n  })`;
+		default: throw new Error(`Unknown Postgres descriptor kind: ${desc.kind}`);
+	}
+}
+function renderPreamble(plan, context) {
+	const hasDataTransform = plan.some((d) => d.kind === "dataTransform");
+	if (hasDataTransform && context.contractJsonPath) {
+		const relativeContractDts = relative(context.packageDir, context.contractJsonPath).replace(/\.json$/, ".d");
+		const importList$1 = [...new Set(plan.map((d) => d.kind))];
+		importList$1.push("TODO");
+		return [
+			`import type { Contract } from "${relativeContractDts}"`,
+			`import { createBuilders } from "@prisma-next/target-postgres/migration-builders"`,
+			"",
+			`const { ${importList$1.join(", ")} } = createBuilders<Contract>()`
+		];
+	}
+	const importList = [...new Set(plan.map((d) => d.kind))];
+	if (importList.length === 0) importList.push("createTable");
+	if (hasDataTransform) importList.push("TODO");
+	return [`import { ${importList.join(", ")} } from "@prisma-next/target-postgres/migration-builders"`];
+}
+/**
+* Render a Postgres descriptor list to a `migration.ts` source string.
+*
+* Internal to the Postgres target — no longer part of the framework SPI.
+* Invoked from two paths:
+*  - the migrations capability's `renderDescriptorTypeScript` hook (called by
+*    the CLI after `planWithDescriptors` to seed an editable authoring
+*    surface, and by `emptyMigration()` to produce the `migration new` stub);
+*  - directly by this package's unit tests.
+*/
+function renderDescriptorTypeScript(descriptors, context) {
+	const preamble = renderPreamble(descriptors, context);
+	const calls = descriptors.map((d) => `  ${renderDescriptor(d)},`);
+	const body = calls.length > 0 ? `\n${calls.join("\n")}\n` : "";
+	return [
+		...preamble,
+		"",
+		`export default () => [${body}]`,
+		""
+	].join("\n");
+}
+
 //#endregion
 //#region src/core/migrations/planner.ts
 const DEFAULT_PLANNER_CONFIG = { defaultSchema: "public" };
@@ -4308,11 +4398,43 @@ function createPostgresMigrationPlanner(config = {}) {
 		...config
 	});
 }
+/**
+* Postgres migration planner.
+*
+* Implements the framework's `MigrationPlanner<'sql', 'postgres'>` directly
+* — meaning it owns `emptyMigration()` and attaches the `renderTypeScript()`
+* stub to success plans (Postgres uses descriptor-flow authoring, so
+* `renderTypeScript()` throws on planner-produced plans). No external wrapper
+* is required at the descriptor level.
+*
+* `plan()` accepts the framework's option shape (with `contract`/`schema`
+* typed as `unknown`); SQL-typed callers may pass the more specific
+* `SqlMigrationPlannerPlanOptions`, since those structurally satisfy the
+* looser framework contract. Internally we treat options as the SQL-typed
+* superset so the existing planner logic stays identical.
+*
+* `fromHash` is accepted but ignored: Postgres is descriptor-flow and never
+* needs it (only class-flow planners like Mongo populate `describe()` from
+* `fromHash`).
+*/
 var PostgresMigrationPlanner = class {
 	constructor(config) {
 		this.config = config;
 	}
 	plan(options) {
+		return this.planSql(options);
+	}
+	emptyMigration(context) {
+		return {
+			targetId: "postgres",
+			destination: { storageHash: context.toHash },
+			operations: [],
+			renderTypeScript() {
+				return renderDescriptorTypeScript([], context);
+			}
+		};
+	}
+	planSql(options) {
 		const schemaName = options.schemaName ?? this.config.defaultSchema;
 		const policyResult = this.ensureAdditivePolicy(options.policy);
 		if (policyResult) return policyResult;
@@ -4335,7 +4457,7 @@ var PostgresMigrationPlanner = class {
 		const sortedTables = sortedEntries(options.contract.storage.tables);
 		const schemaLookups = buildSchemaLookupMap(options.schema);
 		operations.push(...this.buildDatabaseDependencyOperations(options), ...storageTypePlan.operations, ...reconciliationPlan.operations, ...this.buildTableOperations(sortedTables, options.schema, schemaName, codecHooks, storageTypes), ...this.buildColumnOperations(sortedTables, options.schema, schemaLookups, schemaName, codecHooks, storageTypes), ...this.buildPrimaryKeyOperations(sortedTables, options.schema, schemaName), ...this.buildUniqueOperations(sortedTables, schemaLookups, schemaName), ...this.buildIndexOperations(sortedTables, schemaLookups, schemaName), ...this.buildFkBackingIndexOperations(sortedTables, schemaLookups, schemaName), ...this.buildForeignKeyOperations(sortedTables, schemaLookups, schemaName));
-		return plannerSuccess(createMigrationPlan({
+		const plan = createMigrationPlan({
 			targetId: "postgres",
 			origin: null,
 			destination: {
@@ -4343,7 +4465,16 @@ var PostgresMigrationPlanner = class {
 				...ifDefined("profileHash", options.contract.profileHash)
 			},
 			operations
-		}));
+		});
+		return Object.freeze({
+			kind: "success",
+			plan: Object.freeze({
+				...plan,
+				renderTypeScript() {
+					throw errorPlanDoesNotSupportAuthoringSurface({ targetId: "postgres" });
+				}
+			})
+		});
 	}
 	ensureAdditivePolicy(policy) {
 		if (!policy.allowedOperationClasses.includes("additive")) return plannerFailure([{
@@ -5328,6 +5459,9 @@ const postgresTargetDescriptor = {
 				dependencies,
 				db
 			});
+		},
+		renderDescriptorTypeScript(descriptors, context) {
+			return renderDescriptorTypeScript(descriptors, context);
 		}
 	},
 	create() {