@prisma-next/target-postgres 0.13.0-dev.35 → 0.13.0-dev.36

package/dist/postgres-migration-Y4YBJqkS.d.mts

@@ -0,0 +1,181 @@
+import { t as PostgresPlanTargetDetails } from "./planner-target-details-CIY6tLeo.mjs";
+import { n as DataTransformOptions } from "./data-transform-DDgWdB5o.mjs";
+import { s as AlterColumnTypeOptions, w as ForeignKeySpec } from "./op-factory-call-DmQEc3XV.mjs";
+import { DdlColumn, DdlTableConstraint } from "@prisma-next/sql-relational-core/ast";
+import { SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
+import { SqlStorage } from "@prisma-next/sql-contract/types";
+import { Migration } from "@prisma-next/family-sql/migration";
+import { ControlStack } from "@prisma-next/framework-components/control";
+import { Contract } from "@prisma-next/contract/types";
+import { ExecuteRequestLowerer, SqlControlAdapter } from "@prisma-next/family-sql/control-adapter";
+
+//#region src/core/migrations/operations/indexes.d.ts
+interface CreateIndexExtras {
+  readonly type?: string;
+  readonly options?: Record<string, unknown>;
+}
+//#endregion
+//#region src/core/migrations/postgres-migration.d.ts
+/**
+ * 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 facade re-export of this class
+ * from `@prisma-next/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.
+ *
+ * Every method requires an explicit `schema`. Postgres migrations name their
+ * schema deliberately — there is no default and no `search_path`-relative
+ * option. A migration that left the schema unspecified would resolve against
+ * whatever `search_path` the connection happened to carry, and that ambiguity
+ * is an antipattern in a migration. (The unbound/unspecified namespace concept
+ * remains for SQLite, which has no schemas, and for Mongo's connection `db`.)
+ */
+declare abstract class PostgresMigration extends Migration<PostgresPlanTargetDetails, 'postgres'> {
+  readonly targetId: "postgres";
+  /**
+   * 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'>);
+  /**
+   * 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): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  /**
+   * Emit a `CREATE TABLE` migration operation. Builds a typed DDL node from
+   * the supplied options and lowers it through the stored control adapter.
+   * Throws if no adapter is present (i.e. migration instantiated without a stack).
+   */
+  protected createTable(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly ifNotExists?: boolean;
+    readonly columns: readonly DdlColumn[];
+    readonly constraints?: readonly DdlTableConstraint[];
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  /**
+   * Emit a `CREATE SCHEMA` migration operation. Builds a typed DDL node from
+   * the supplied options and lowers it through the stored control adapter.
+   * Throws if no adapter is present (i.e. migration instantiated without a stack).
+   */
+  protected createSchema(options: {
+    readonly schema: string;
+    readonly ifNotExists?: boolean;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected addColumn(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly column: DdlColumn;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected addPrimaryKey(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly constraint: string;
+    readonly columns: readonly string[];
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected addUnique(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly constraint: string;
+    readonly columns: readonly string[];
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected addForeignKey(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly foreignKey: ForeignKeySpec;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected addCheckConstraint(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly constraint: string;
+    readonly column: string;
+    readonly values: readonly string[];
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected dropCheckConstraint(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly constraint: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected dropConstraint(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly constraint: string;
+    readonly kind?: 'foreignKey' | 'unique' | 'primaryKey';
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected dropTable(options: {
+    readonly schema: string;
+    readonly table: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected dropColumn(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly column: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected alterColumnType(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly column: string;
+    readonly options: AlterColumnTypeOptions;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected setNotNull(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly column: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected dropNotNull(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly column: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected setDefault(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly column: string;
+    readonly defaultSql: string;
+    readonly operationClass?: 'additive' | 'widening';
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected dropDefault(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly column: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected createIndex(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly index: string;
+    readonly columns: readonly string[];
+    readonly extras?: CreateIndexExtras;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected dropIndex(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly index: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+  protected installExtension(options: {
+    readonly extensionName: string;
+    readonly invariantId: string;
+    readonly id: string;
+    readonly label?: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>>;
+}
+//#endregion
+export { PostgresMigration as t };
+//# sourceMappingURL=postgres-migration-Y4YBJqkS.d.mts.map

package/dist/postgres-migration-Y4YBJqkS.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-migration-Y4YBJqkS.d.mts","names":[],"sources":["../src/core/migrations/operations/indexes.ts","../src/core/migrations/postgres-migration.ts"],"mappings":"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"}

package/dist/postgres-migration-otiaw3Ru.mjs

@@ -0,0 +1,145 @@
+import { C as SetNotNullCall, D as installExtension, S as SetDefaultCall, _ as DropDefaultCall, b as DropTableCall, c as AlterColumnTypeCall, d as CreateSchemaCall, f as CreateTableCall, g as DropConstraintCall, h as DropColumnCall, m as DropCheckConstraintCall, n as AddColumnCall, o as AddPrimaryKeyCall, r as AddForeignKeyCall, s as AddUniqueCall, t as AddCheckConstraintCall, u as CreateIndexCall, v as DropIndexCall, y as DropNotNullCall } from "./op-factory-call-B1bXWtfa.mjs";
+import { t as errorPostgresMigrationStackMissing } from "./errors-CUk87ByX.mjs";
+import { t as dataTransform } from "./data-transform-BOWpliq8.mjs";
+import { Migration } from "@prisma-next/family-sql/migration";
+//#region src/core/migrations/postgres-migration.ts
+/**
+* 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 facade re-export of this class
+* from `@prisma-next/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.
+*
+* Every method requires an explicit `schema`. Postgres migrations name their
+* schema deliberately — there is no default and no `search_path`-relative
+* option. A migration that left the schema unspecified would resolve against
+* whatever `search_path` the connection happened to carry, and that ambiguity
+* is an antipattern in a migration. (The unbound/unspecified namespace concept
+* remains for SQLite, which has no schemas, and for Mongo's connection `db`.)
+*/
+var PostgresMigration = class extends Migration {
+	targetId = "postgres";
+	/**
+	* 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.
+	*/
+	controlAdapter;
+	constructor(stack) {
+		super(stack);
+		this.controlAdapter = stack?.adapter ? stack.adapter.create(stack) : void 0;
+	}
+	/**
+	* 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.
+	*/
+	dataTransform(contract, name, options) {
+		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
+		return dataTransform(contract, name, options, this.controlAdapter);
+	}
+	/**
+	* Emit a `CREATE TABLE` migration operation. Builds a typed DDL node from
+	* the supplied options and lowers it through the stored control adapter.
+	* Throws if no adapter is present (i.e. migration instantiated without a stack).
+	*/
+	createTable(options) {
+		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
+		return new CreateTableCall(options.schema, options.table, options.columns, options.constraints).toOp(this.controlAdapter);
+	}
+	/**
+	* Emit a `CREATE SCHEMA` migration operation. Builds a typed DDL node from
+	* the supplied options and lowers it through the stored control adapter.
+	* Throws if no adapter is present (i.e. migration instantiated without a stack).
+	*/
+	createSchema(options) {
+		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
+		return new CreateSchemaCall(options.schema).toOp(this.controlAdapter);
+	}
+	addColumn(options) {
+		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
+		return new AddColumnCall(options.schema, options.table, options.column).toOp(this.controlAdapter);
+	}
+	addPrimaryKey(options) {
+		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
+		return new AddPrimaryKeyCall(options.schema, options.table, options.constraint, options.columns).toOp(this.controlAdapter);
+	}
+	addUnique(options) {
+		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
+		return new AddUniqueCall(options.schema, options.table, options.constraint, options.columns).toOp(this.controlAdapter);
+	}
+	addForeignKey(options) {
+		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
+		return new AddForeignKeyCall(options.schema, options.table, options.foreignKey).toOp(this.controlAdapter);
+	}
+	addCheckConstraint(options) {
+		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
+		return new AddCheckConstraintCall(options.schema, options.table, options.constraint, options.column, options.values).toOp(this.controlAdapter);
+	}
+	dropCheckConstraint(options) {
+		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
+		return new DropCheckConstraintCall(options.schema, options.table, options.constraint).toOp(this.controlAdapter);
+	}
+	dropConstraint(options) {
+		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
+		return new DropConstraintCall(options.schema, options.table, options.constraint, options.kind ?? "unique").toOp(this.controlAdapter);
+	}
+	dropTable(options) {
+		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
+		return new DropTableCall(options.schema, options.table).toOp(this.controlAdapter);
+	}
+	dropColumn(options) {
+		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
+		return new DropColumnCall(options.schema, options.table, options.column).toOp(this.controlAdapter);
+	}
+	alterColumnType(options) {
+		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
+		return new AlterColumnTypeCall(options.schema, options.table, options.column, options.options).toOp(this.controlAdapter);
+	}
+	setNotNull(options) {
+		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
+		return new SetNotNullCall(options.schema, options.table, options.column).toOp(this.controlAdapter);
+	}
+	dropNotNull(options) {
+		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
+		return new DropNotNullCall(options.schema, options.table, options.column).toOp(this.controlAdapter);
+	}
+	setDefault(options) {
+		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
+		return new SetDefaultCall(options.schema, options.table, options.column, options.defaultSql, options.operationClass).toOp(this.controlAdapter);
+	}
+	dropDefault(options) {
+		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
+		return new DropDefaultCall(options.schema, options.table, options.column).toOp(this.controlAdapter);
+	}
+	createIndex(options) {
+		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
+		return new CreateIndexCall(options.schema, options.table, options.index, options.columns, options.extras).toOp(this.controlAdapter);
+	}
+	dropIndex(options) {
+		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
+		return new DropIndexCall(options.schema, options.table, options.index).toOp(this.controlAdapter);
+	}
+	installExtension(options) {
+		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
+		return installExtension(options, this.controlAdapter);
+	}
+};
+//#endregion
+export { PostgresMigration as t };
+
+//# sourceMappingURL=postgres-migration-otiaw3Ru.mjs.map

package/dist/postgres-migration-otiaw3Ru.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-migration-otiaw3Ru.mjs","names":["SqlMigration"],"sources":["../src/core/migrations/postgres-migration.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';\nimport { Migration as SqlMigration } from '@prisma-next/family-sql/migration';\nimport type { ControlStack } from '@prisma-next/framework-components/control';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';\nimport { errorPostgresMigrationStackMissing } from '../errors';\nimport {\n  AddCheckConstraintCall,\n  AddColumnCall,\n  AddForeignKeyCall,\n  AddPrimaryKeyCall,\n  AddUniqueCall,\n  AlterColumnTypeCall,\n  type AlterColumnTypeOptions,\n  CreateIndexCall,\n  CreateSchemaCall,\n  CreateTableCall,\n  DropCheckConstraintCall,\n  DropColumnCall,\n  DropConstraintCall,\n  DropDefaultCall,\n  DropIndexCall,\n  DropNotNullCall,\n  DropTableCall,\n  SetDefaultCall,\n  SetNotNullCall,\n} from './op-factory-call';\nimport { type DataTransformOptions, dataTransform } from './operations/data-transform';\nimport { installExtension } from './operations/dependencies';\nimport type { CreateIndexExtras } from './operations/indexes';\nimport type { ForeignKeySpec } from './operations/shared';\nimport type { PostgresPlanTargetDetails } from './planner-target-details';\n\n/**\n * Target-owned base class for Postgres migrations.\n *\n * Fixes the `SqlMigration` generic to `PostgresPlanTargetDetails` and the\n * abstract `targetId` to the Postgres target-id string literal, so both\n * user-authored migrations and renderer-generated scaffolds (the output of\n * `renderCallsToTypeScript`) can extend `PostgresMigration` directly without\n * redeclaring target-local identity.\n *\n * Mirrors `MongoMigration` in `@prisma-next/family-mongo`: the renderer\n * emits `extends Migration` against a facade re-export of this class\n * from `@prisma-next/postgres/migration`, keeping the authoring surface\n * target-scoped rather than family-scoped.\n *\n * The constructor materializes a single Postgres `SqlControlAdapter` from\n * `stack.adapter.create(stack)` and stores it; the protected `dataTransform`\n * instance method forwards to the free `dataTransform` factory with that\n * stored adapter, so user migrations can write `this.dataTransform(...)`\n * without threading the adapter through every call.\n *\n * Every method requires an explicit `schema`. Postgres migrations name their\n * schema deliberately — there is no default and no `search_path`-relative\n * option. A migration that left the schema unspecified would resolve against\n * whatever `search_path` the connection happened to carry, and that ambiguity\n * is an antipattern in a migration. (The unbound/unspecified namespace concept\n * remains for SQLite, which has no schemas, and for Mongo's connection `db`.)\n */\nexport abstract class PostgresMigration extends SqlMigration<\n  PostgresPlanTargetDetails,\n  'postgres'\n> {\n  readonly targetId = 'postgres' as const;\n\n  /**\n   * Materialized Postgres control adapter, created once per migration\n   * instance from the injected stack. `undefined` only when the migration\n   * was instantiated without a stack (test fixtures); `dataTransform`\n   * throws in that case to surface the misuse.\n   */\n  protected readonly controlAdapter: SqlControlAdapter<'postgres'> | undefined;\n\n  constructor(stack?: ControlStack<'sql', 'postgres'>) {\n    super(stack);\n    // The descriptor `create()` is typed as the wider `ControlAdapterInstance`;\n    // the Postgres descriptor concretely returns a `SqlControlAdapter<'postgres'>`,\n    // so the cast holds for any Postgres-target stack assembled at runtime.\n    this.controlAdapter = stack?.adapter\n      ? (stack.adapter.create(stack) as SqlControlAdapter<'postgres'>)\n      : undefined;\n  }\n\n  /**\n   * Instance-method wrapper around the free `dataTransform` factory that\n   * supplies the stored control adapter. Authors call this from inside\n   * `get operations()`; the adapter argument is hidden from the call site.\n   */\n  protected dataTransform<TContract extends Contract<SqlStorage>>(\n    contract: TContract,\n    name: string,\n    options: DataTransformOptions,\n  ): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return dataTransform(contract, name, options, this.controlAdapter);\n  }\n\n  /**\n   * Emit a `CREATE TABLE` migration operation. Builds a typed DDL node from\n   * the supplied options and lowers it through the stored control adapter.\n   * Throws if no adapter is present (i.e. migration instantiated without a stack).\n   */\n  protected createTable(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly ifNotExists?: boolean;\n    readonly columns: readonly DdlColumn[];\n    readonly constraints?: readonly DdlTableConstraint[];\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new CreateTableCall(\n      options.schema,\n      options.table,\n      options.columns,\n      options.constraints,\n    ).toOp(this.controlAdapter);\n  }\n\n  /**\n   * Emit a `CREATE SCHEMA` migration operation. Builds a typed DDL node from\n   * the supplied options and lowers it through the stored control adapter.\n   * Throws if no adapter is present (i.e. migration instantiated without a stack).\n   */\n  protected createSchema(options: {\n    readonly schema: string;\n    readonly ifNotExists?: boolean;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new CreateSchemaCall(options.schema).toOp(this.controlAdapter);\n  }\n\n  protected addColumn(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: DdlColumn;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new AddColumnCall(options.schema, options.table, options.column).toOp(\n      this.controlAdapter,\n    );\n  }\n\n  protected addPrimaryKey(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly constraint: string;\n    readonly columns: readonly string[];\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new AddPrimaryKeyCall(\n      options.schema,\n      options.table,\n      options.constraint,\n      options.columns,\n    ).toOp(this.controlAdapter);\n  }\n\n  protected addUnique(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly constraint: string;\n    readonly columns: readonly string[];\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new AddUniqueCall(\n      options.schema,\n      options.table,\n      options.constraint,\n      options.columns,\n    ).toOp(this.controlAdapter);\n  }\n\n  protected addForeignKey(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly foreignKey: ForeignKeySpec;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new AddForeignKeyCall(options.schema, options.table, options.foreignKey).toOp(\n      this.controlAdapter,\n    );\n  }\n\n  protected addCheckConstraint(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly constraint: string;\n    readonly column: string;\n    readonly values: readonly string[];\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new AddCheckConstraintCall(\n      options.schema,\n      options.table,\n      options.constraint,\n      options.column,\n      options.values,\n    ).toOp(this.controlAdapter);\n  }\n\n  protected dropCheckConstraint(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly constraint: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new DropCheckConstraintCall(options.schema, options.table, options.constraint).toOp(\n      this.controlAdapter,\n    );\n  }\n\n  protected dropConstraint(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly constraint: string;\n    readonly kind?: 'foreignKey' | 'unique' | 'primaryKey';\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new DropConstraintCall(\n      options.schema,\n      options.table,\n      options.constraint,\n      options.kind ?? 'unique',\n    ).toOp(this.controlAdapter);\n  }\n\n  protected dropTable(options: {\n    readonly schema: string;\n    readonly table: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new DropTableCall(options.schema, options.table).toOp(this.controlAdapter);\n  }\n\n  protected dropColumn(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new DropColumnCall(options.schema, options.table, options.column).toOp(\n      this.controlAdapter,\n    );\n  }\n\n  protected alterColumnType(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: string;\n    readonly options: AlterColumnTypeOptions;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new AlterColumnTypeCall(\n      options.schema,\n      options.table,\n      options.column,\n      options.options,\n    ).toOp(this.controlAdapter);\n  }\n\n  protected setNotNull(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new SetNotNullCall(options.schema, options.table, options.column).toOp(\n      this.controlAdapter,\n    );\n  }\n\n  protected dropNotNull(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new DropNotNullCall(options.schema, options.table, options.column).toOp(\n      this.controlAdapter,\n    );\n  }\n\n  protected setDefault(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: string;\n    readonly defaultSql: string;\n    readonly operationClass?: 'additive' | 'widening';\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new SetDefaultCall(\n      options.schema,\n      options.table,\n      options.column,\n      options.defaultSql,\n      options.operationClass,\n    ).toOp(this.controlAdapter);\n  }\n\n  protected dropDefault(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new DropDefaultCall(options.schema, options.table, options.column).toOp(\n      this.controlAdapter,\n    );\n  }\n\n  protected createIndex(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly index: string;\n    readonly columns: readonly string[];\n    readonly extras?: CreateIndexExtras;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new CreateIndexCall(\n      options.schema,\n      options.table,\n      options.index,\n      options.columns,\n      options.extras,\n    ).toOp(this.controlAdapter);\n  }\n\n  protected dropIndex(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly index: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new DropIndexCall(options.schema, options.table, options.index).toOp(\n      this.controlAdapter,\n    );\n  }\n\n  protected installExtension(options: {\n    readonly extensionName: string;\n    readonly invariantId: string;\n    readonly id: string;\n    readonly label?: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return installExtension(options, this.controlAdapter);\n  }\n}\n"],"mappings":"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"}

package/dist/{postgres-schema-CDaLWZwd.mjs → postgres-schema-COGZ1ark.mjs}

@@ -1,7 +1,24 @@
+import { _ as PG_TEXT_CODEC_ID } from "./codec-ids-BvytN2P8.mjs";
 import { n as escapeLiteral } from "./sql-utils-DcfMz4MQ.mjs";
+import { TableSource } from "@prisma-next/sql-relational-core/ast";
 import { blindCast } from "@prisma-next/utils/casts";
+import { ifDefined } from "@prisma-next/utils/defined";
 import { NamespaceBase, UNBOUND_NAMESPACE_ID, freezeNode, hydrateNamespaceEntities } from "@prisma-next/framework-components/ir";
 import { composeSqlEntityKinds } from "@prisma-next/sql-contract/entity-kinds";
+import { cfExpr } from "@prisma-next/sql-relational-core/contract-free";
+//#region src/core/ast/table-source.ts
+var PostgresTableSource = class extends TableSource {
+	schema;
+	constructor(options) {
+		super(options.name, options.alias);
+		this.schema = options.schema;
+		this.freeze();
+	}
+	rewrite(rewriter) {
+		return rewriter.tableSource ? rewriter.tableSource(this) : this;
+	}
+};
+//#endregion
 //#region src/core/postgres-schema.ts
 /**
 * Postgres target `Namespace` concretion — a Postgres schema (`CREATE
@@ -90,15 +107,39 @@ var PostgresSchema = class extends NamespaceBase {
 		return `'${escapeLiteral(this.id)}'`;
 	}
 	/**
+	* Typed-AST counterpart of {@link schemaSqlExpression}: the expression a
+	* builder-built catalog check compares `n.nspname` / `table_schema`
+	* against. Named schemas bind the schema name as a text parameter; the
+	* unbound singleton overrides this to the opaque `current_schema()`
+	* expression so the live connection's `search_path` decides at runtime.
+	*/
+	schemaFilterExpression() {
+		return cfExpr.param(this.id, PG_TEXT_CODEC_ID);
+	}
+	/**
+	* Typed-AST counterpart of {@link qualifyTable}: the FROM source a
+	* builder-built check uses to address a user table in this namespace.
+	* Named schemas qualify (`"schema"."table"`); the unbound singleton
+	* overrides this to leave the table unqualified so `search_path`
+	* resolves it at runtime.
+	*/
+	tableSource(tableName, alias) {
+		return new PostgresTableSource({
+			name: tableName,
+			schema: this.id,
+			...ifDefined("alias", alias)
+		});
+	}
+	/**
 	* The bare schema name a DDL planner should target when emitting
 	* statements that need to identify this namespace in the live
 	* database (e.g. `CREATE TABLE "<ddlSchemaName>"."<table>" …`,
 	* catalog filters, planner conflict lookups). Named schemas resolve
 	* to their own id. The `PostgresUnboundSchema` singleton inherits
 	* this and returns `UNBOUND_NAMESPACE_ID` — callers that dispatch
-	* through `qualifyTableName` / `toRegclassLiteral` route through the
-	* polymorphic `PostgresUnboundSchema` overrides and produce
-	* unqualified (search-path-resolved) output automatically.
+	* through `qualifyTableName` route through the polymorphic
+	* `PostgresUnboundSchema` overrides and produce unqualified
+	* (search-path-resolved) output automatically.
 	*/
 	ddlSchemaName(_storage) {
 		return this.id;
@@ -119,9 +160,9 @@ var PostgresSchema = class extends NamespaceBase {
 * `search_path`).
 *
 * `ddlSchemaName` is inherited from `PostgresSchema` and returns
-* `UNBOUND_NAMESPACE_ID`. Downstream helpers (`qualifyTableName`,
-* `toRegclassLiteral`) route through the polymorphic factory and
-* produce unqualified output automatically.
+* `UNBOUND_NAMESPACE_ID`. Downstream helpers such as `qualifyTableName`
+* route through the polymorphic factory and produce unqualified output
+* automatically.
 */
 var PostgresUnboundSchema = class PostgresUnboundSchema extends PostgresSchema {
 	static instance = new PostgresUnboundSchema();
@@ -140,6 +181,18 @@ var PostgresUnboundSchema = class PostgresUnboundSchema extends PostgresSchema {
 	schemaSqlExpression() {
 		return "current_schema()";
 	}
+	schemaFilterExpression() {
+		return cfExpr.raw("current_schema()", {
+			codecId: PG_TEXT_CODEC_ID,
+			nullable: false
+		});
+	}
+	tableSource(tableName, alias) {
+		return new PostgresTableSource({
+			name: tableName,
+			...ifDefined("alias", alias)
+		});
+	}
 };
 PostgresSchema.unbound = PostgresUnboundSchema.instance;
 /**
@@ -177,6 +230,6 @@ function postgresCreateNamespace(input) {
 	return new PostgresSchema(schemaInput);
 }
 //#endregion
-export { postgresCreateNamespace as i, PostgresUnboundSchema as n, isPostgresSchema as r, PostgresSchema as t };
+export { PostgresTableSource as a, postgresCreateNamespace as i, PostgresUnboundSchema as n, isPostgresSchema as r, PostgresSchema as t };
 
-//# sourceMappingURL=postgres-schema-CDaLWZwd.mjs.map
+//# sourceMappingURL=postgres-schema-COGZ1ark.mjs.map

package/dist/postgres-schema-COGZ1ark.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-schema-COGZ1ark.mjs","names":[],"sources":["../src/core/ast/table-source.ts","../src/core/postgres-schema.ts"],"sourcesContent":["import {\n  type AnyFromSource,\n  type AstRewriter,\n  TableSource,\n} from '@prisma-next/sql-relational-core/ast';\n\nexport class PostgresTableSource extends TableSource {\n  readonly schema: string | undefined;\n\n  constructor(options: {\n    readonly name: string;\n    readonly schema?: string;\n    readonly alias?: string;\n  }) {\n    super(options.name, options.alias);\n    this.schema = options.schema;\n    this.freeze();\n  }\n\n  override rewrite(rewriter: AstRewriter): AnyFromSource {\n    return rewriter.tableSource ? rewriter.tableSource(this) : this;\n  }\n}\n","import {\n  freezeNode,\n  hydrateNamespaceEntities,\n  NamespaceBase,\n  UNBOUND_NAMESPACE_ID,\n} from '@prisma-next/framework-components/ir';\nimport { composeSqlEntityKinds } from '@prisma-next/sql-contract/entity-kinds';\nimport type {\n  SqlNamespaceEntries,\n  SqlNamespaceTablesInput,\n  SqlStorage,\n  StorageTable,\n  StorageValueSet,\n} from '@prisma-next/sql-contract/types';\nimport { type CfExpr, cfExpr } from '@prisma-next/sql-relational-core/contract-free';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { PostgresTableSource } from './ast/table-source';\nimport { PG_TEXT_CODEC_ID } from './codec-ids';\nimport { escapeLiteral } from './sql-utils';\n\nexport interface PostgresSchemaInput {\n  readonly id: string;\n  readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>;\n}\n\n/**\n * Postgres target `Namespace` concretion — a Postgres schema (`CREATE\n * SCHEMA …`). Each Postgres `SqlStorage` carries a\n * `namespaces: Record<NamespaceId, PostgresSchema>` map populated by\n * the Postgres PSL interpreter from `namespace { … }` AST buckets.\n *\n * `entries` holds entity-kind maps (`table`, `valueSet`). Qualifier\n * emission is the rendering seam: DDL / SQL emission asks the namespace\n * for its qualifier (`\"<schema>\"`) or for a qualified table name\n * (`\"<schema>\".\"<table>\"`) and consumes the result polymorphically.\n * The unbound singleton below overrides these methods to elide the\n * prefix entirely — call sites stay polymorphic and never branch on\n * `id === UNBOUND_NAMESPACE_ID`.\n */\nexport class PostgresSchema extends NamespaceBase {\n  /**\n   * Stable singleton reference for the late-bound slot. Materialised\n   * lazily below the singleton subclass declaration so the static\n   * initialiser sees the subclass before assigning. Consumers always\n   * reach for `PostgresSchema.unbound` (or `PostgresUnboundSchema.instance`\n   * — same identity).\n   */\n  static unbound: PostgresUnboundSchema;\n\n  declare readonly kind: 'schema';\n  readonly id: string;\n  readonly entries: SqlNamespaceEntries;\n\n  constructor(input: PostgresSchemaInput) {\n    super();\n    this.id = input.id;\n\n    const dispatched = hydrateNamespaceEntities(input.entries, composeSqlEntityKinds(), 'carry');\n\n    // Drop an empty valueSet so presence signals non-emptiness.\n    const valueSetRaw = dispatched['valueSet'];\n    const withPresence =\n      valueSetRaw !== undefined && Object.keys(valueSetRaw).length === 0\n        ? { ...dispatched, valueSet: undefined }\n        : dispatched;\n\n    this.entries = Object.freeze(\n      blindCast<\n        SqlNamespaceEntries,\n        'composeSqlEntityKinds() supplies table→StorageTable and valueSet→StorageValueSet descriptors, so this open-dict result holds exactly the typed members SqlNamespaceEntries declares; the descriptor Map erases those per-kind Node types from the return.'\n      >(withPresence),\n    );\n    Object.defineProperty(this, 'kind', {\n      value: 'schema',\n      writable: false,\n      enumerable: false,\n      configurable: true,\n    });\n    freezeNode(this);\n  }\n\n  get table(): Readonly<Record<string, StorageTable>> {\n    return this.entries.table ?? Object.freeze({});\n  }\n\n  get valueSet(): Readonly<Record<string, StorageValueSet>> | undefined {\n    return this.entries.valueSet;\n  }\n\n  /**\n   * The bare schema qualifier as it would appear in a rendered SQL\n   * fragment (already quoted). The unbound-schema singleton overrides\n   * this to return `''`.\n   */\n  qualifier(): string {\n    return `\"${this.id}\"`;\n  }\n\n  /**\n   * Qualify a table name with the schema prefix\n   * (`\"<schema>\".\"<table>\"`). The unbound-schema singleton overrides\n   * this to emit just `\"<table>\"` so the resolved DDL is unqualified\n   * and `search_path` decides where the object lands at runtime.\n   */\n  qualifyTable(tableName: string): string {\n    return `\"${this.id}\".\"${tableName}\"`;\n  }\n\n  /**\n   * Render a SQL string-literal containing the qualified-name form\n   * suitable for `to_regclass(...)` arguments (e.g. `'\"public\".\"user\"'`).\n   * The unbound singleton overrides this to elide the schema prefix\n   * (`'\"user\"'`) so `search_path` resolves the object at runtime.\n   */\n  regclassLiteral(name: string): string {\n    return `'${escapeLiteral(this.qualifyTable(name))}'`;\n  }\n\n  /**\n   * Render a SQL expression that evaluates to this namespace's schema\n   * name at runtime, ready to drop into a `WHERE table_schema = …` /\n   * `WHERE n.nspname = …` clause. Named schemas emit a quoted SQL\n   * literal (`'public'`); the unbound singleton overrides this to emit\n   * `current_schema()` so catalog queries match whichever schema the\n   * connection's `search_path` resolved at runtime.\n   */\n  schemaSqlExpression(): string {\n    return `'${escapeLiteral(this.id)}'`;\n  }\n\n  /**\n   * Typed-AST counterpart of {@link schemaSqlExpression}: the expression a\n   * builder-built catalog check compares `n.nspname` / `table_schema`\n   * against. Named schemas bind the schema name as a text parameter; the\n   * unbound singleton overrides this to the opaque `current_schema()`\n   * expression so the live connection's `search_path` decides at runtime.\n   */\n  schemaFilterExpression(): CfExpr {\n    return cfExpr.param(this.id, PG_TEXT_CODEC_ID);\n  }\n\n  /**\n   * Typed-AST counterpart of {@link qualifyTable}: the FROM source a\n   * builder-built check uses to address a user table in this namespace.\n   * Named schemas qualify (`\"schema\".\"table\"`); the unbound singleton\n   * overrides this to leave the table unqualified so `search_path`\n   * resolves it at runtime.\n   */\n  tableSource(tableName: string, alias?: string): PostgresTableSource {\n    return new PostgresTableSource({\n      name: tableName,\n      schema: this.id,\n      ...ifDefined('alias', alias),\n    });\n  }\n\n  /**\n   * The bare schema name a DDL planner should target when emitting\n   * statements that need to identify this namespace in the live\n   * database (e.g. `CREATE TABLE \"<ddlSchemaName>\".\"<table>\" …`,\n   * catalog filters, planner conflict lookups). Named schemas resolve\n   * to their own id. The `PostgresUnboundSchema` singleton inherits\n   * this and returns `UNBOUND_NAMESPACE_ID` — callers that dispatch\n   * through `qualifyTableName` route through the polymorphic\n   * `PostgresUnboundSchema` overrides and produce unqualified\n   * (search-path-resolved) output automatically.\n   */\n  ddlSchemaName(_storage: SqlStorage): string {\n    return this.id;\n  }\n}\n\n/**\n * Singleton subclass for the reserved sentinel namespace id\n * (`UNBOUND_NAMESPACE_ID`) — the late-bound Postgres slot whose binding\n * the connection's `search_path` resolves at runtime. Overrides\n * qualifier emission to elide the schema prefix; call sites that consume\n * `qualifier()` / `qualifyTable()` get unqualified output without\n * branching on the namespace id.\n *\n * This is the target-side materialization of \"the framework provides\n * affordances; targets implement specifics\": the framework names the\n * sentinel; Postgres decides what late-bound means here (the table\n * name, naked — the schema is supplied by the live connection's\n * `search_path`).\n *\n * `ddlSchemaName` is inherited from `PostgresSchema` and returns\n * `UNBOUND_NAMESPACE_ID`. Downstream helpers such as `qualifyTableName`\n * route through the polymorphic factory and produce unqualified output\n * automatically.\n */\nexport class PostgresUnboundSchema extends PostgresSchema {\n  static readonly instance: PostgresUnboundSchema = new PostgresUnboundSchema();\n\n  constructor(input?: PostgresSchemaInput) {\n    super(input ?? { id: UNBOUND_NAMESPACE_ID, entries: { table: {} } });\n  }\n\n  override qualifier(): string {\n    return '';\n  }\n\n  override qualifyTable(tableName: string): string {\n    return `\"${tableName}\"`;\n  }\n\n  override schemaSqlExpression(): string {\n    return 'current_schema()';\n  }\n\n  override schemaFilterExpression(): CfExpr {\n    return cfExpr.raw('current_schema()', { codecId: PG_TEXT_CODEC_ID, nullable: false });\n  }\n\n  override tableSource(tableName: string, alias?: string): PostgresTableSource {\n    return new PostgresTableSource({\n      name: tableName,\n      ...ifDefined('alias', alias),\n    });\n  }\n}\n\nPostgresSchema.unbound = PostgresUnboundSchema.instance;\n\n/**\n * Narrow an arbitrary namespace (or `undefined`) to `PostgresSchema`\n * so callers can dispatch to the polymorphic emission methods without\n * branching at the call site. Uses the structural `kind` discriminator\n * (`'schema'`) rather than `instanceof` so the check survives realm /\n * bundle / hot-reload boundaries — matching the rest of the IR's\n * narrowing convention. `PostgresUnboundSchema` passes through because\n * it inherits the same `kind: 'schema'` from `PostgresSchema`.\n */\nexport function isPostgresSchema(ns: unknown): ns is PostgresSchema {\n  return (ns as { kind?: unknown } | null | undefined)?.kind === 'schema';\n}\n\n/**\n * Target-supplied `Namespace` factory the Postgres target plumbs\n * through `defineContract({ createNamespace })` and the SQL PSL\n * interpreter. Returns the unbound singleton for the framework\n * sentinel and a fresh `PostgresSchema` for any other coordinate.\n *\n * The factory has no per-call state — every named id deterministically\n * maps to a distinct schema instance — so callers can pass it through\n * by reference and trust the resulting `SqlStorage.namespaces` map to\n * be value-stable for a given input set.\n */\nexport function postgresCreateNamespace(input: SqlNamespaceTablesInput): PostgresSchema {\n  const schemaInput: PostgresSchemaInput = {\n    id: input.id,\n    entries: {\n      ...input.entries,\n      table: input.entries['table'] ?? {},\n    },\n  };\n  if (input.id === UNBOUND_NAMESPACE_ID) {\n    return new PostgresUnboundSchema(schemaInput);\n  }\n  return new PostgresSchema(schemaInput);\n}\n"],"mappings":";;;;;;;;;AAMA,IAAa,sBAAb,cAAyC,YAAY;CACnD;CAEA,YAAY,SAIT;EACD,MAAM,QAAQ,MAAM,QAAQ,KAAK;EACjC,KAAK,SAAS,QAAQ;EACtB,KAAK,OAAO;CACd;CAEA,QAAiB,UAAsC;EACrD,OAAO,SAAS,cAAc,SAAS,YAAY,IAAI,IAAI;CAC7D;AACF;;;;;;;;;;;;;;;;;ACkBA,IAAa,iBAAb,cAAoC,cAAc;;;;;;;;CAQhD,OAAO;CAGP;CACA;CAEA,YAAY,OAA4B;EACtC,MAAM;EACN,KAAK,KAAK,MAAM;EAEhB,MAAM,aAAa,yBAAyB,MAAM,SAAS,sBAAsB,GAAG,OAAO;EAG3F,MAAM,cAAc,WAAW;EAC/B,MAAM,eACJ,gBAAgB,KAAA,KAAa,OAAO,KAAK,WAAW,CAAC,CAAC,WAAW,IAC7D;GAAE,GAAG;GAAY,UAAU,KAAA;EAAU,IACrC;EAEN,KAAK,UAAU,OAAO,OACpB,UAGE,YAAY,CAChB;EACA,OAAO,eAAe,MAAM,QAAQ;GAClC,OAAO;GACP,UAAU;GACV,YAAY;GACZ,cAAc;EAChB,CAAC;EACD,WAAW,IAAI;CACjB;CAEA,IAAI,QAAgD;EAClD,OAAO,KAAK,QAAQ,SAAS,OAAO,OAAO,CAAC,CAAC;CAC/C;CAEA,IAAI,WAAkE;EACpE,OAAO,KAAK,QAAQ;CACtB;;;;;;CAOA,YAAoB;EAClB,OAAO,IAAI,KAAK,GAAG;CACrB;;;;;;;CAQA,aAAa,WAA2B;EACtC,OAAO,IAAI,KAAK,GAAG,KAAK,UAAU;CACpC;;;;;;;CAQA,gBAAgB,MAAsB;EACpC,OAAO,IAAI,cAAc,KAAK,aAAa,IAAI,CAAC,EAAE;CACpD;;;;;;;;;CAUA,sBAA8B;EAC5B,OAAO,IAAI,cAAc,KAAK,EAAE,EAAE;CACpC;;;;;;;;CASA,yBAAiC;EAC/B,OAAO,OAAO,MAAM,KAAK,IAAI,gBAAgB;CAC/C;;;;;;;;CASA,YAAY,WAAmB,OAAqC;EAClE,OAAO,IAAI,oBAAoB;GAC7B,MAAM;GACN,QAAQ,KAAK;GACb,GAAG,UAAU,SAAS,KAAK;EAC7B,CAAC;CACH;;;;;;;;;;;;CAaA,cAAc,UAA8B;EAC1C,OAAO,KAAK;CACd;AACF;;;;;;;;;;;;;;;;;;;;AAqBA,IAAa,wBAAb,MAAa,8BAA8B,eAAe;CACxD,OAAgB,WAAkC,IAAI,sBAAsB;CAE5E,YAAY,OAA6B;EACvC,MAAM,SAAS;GAAE,IAAI;GAAsB,SAAS,EAAE,OAAO,CAAC,EAAE;EAAE,CAAC;CACrE;CAEA,YAA6B;EAC3B,OAAO;CACT;CAEA,aAAsB,WAA2B;EAC/C,OAAO,IAAI,UAAU;CACvB;CAEA,sBAAuC;EACrC,OAAO;CACT;CAEA,yBAA0C;EACxC,OAAO,OAAO,IAAI,oBAAoB;GAAE,SAAS;GAAkB,UAAU;EAAM,CAAC;CACtF;CAEA,YAAqB,WAAmB,OAAqC;EAC3E,OAAO,IAAI,oBAAoB;GAC7B,MAAM;GACN,GAAG,UAAU,SAAS,KAAK;EAC7B,CAAC;CACH;AACF;AAEA,eAAe,UAAU,sBAAsB;;;;;;;;;;AAW/C,SAAgB,iBAAiB,IAAmC;CAClE,OAAQ,IAA8C,SAAS;AACjE;;;;;;;;;;;;AAaA,SAAgB,wBAAwB,OAAgD;CACtF,MAAM,cAAmC;EACvC,IAAI,MAAM;EACV,SAAS;GACP,GAAG,MAAM;GACT,OAAO,MAAM,QAAQ,YAAY,CAAC;EACpC;CACF;CACA,IAAI,MAAM,OAAO,sBACf,OAAO,IAAI,sBAAsB,WAAW;CAE9C,OAAO,IAAI,eAAe,WAAW;AACvC"}

package/dist/runtime.mjs

@@ -1,5 +1,5 @@
 import { t as postgresTargetDescriptorMetaRuntime } from "./descriptor-meta-runtime-e5f2tscJ.mjs";
-import { t as PostgresContractSerializer } from "./postgres-contract-serializer-sdg1B6Og.mjs";
+import { t as PostgresContractSerializer } from "./postgres-contract-serializer-E92REOFk.mjs";
 //#region src/exports/runtime.ts
 /**
 * Target-postgres deliberately does NOT import `SqlRuntimeTargetDescriptor` from `@prisma-next/sql-runtime`. The target package is a control-plane residence and must not pull the SQL execution-plane package into its dependency closure. The runtime descriptor here is shaped to satisfy the framework's `RuntimeTargetDescriptor` plus the structural `SqlStaticContributions` (`codecs:` returning a descriptor list) that

package/dist/table-source-BvFo7gVs.d.mts

@@ -0,0 +1,15 @@
+import { AnyFromSource, AstRewriter, TableSource } from "@prisma-next/sql-relational-core/ast";
+
+//#region src/core/ast/table-source.d.ts
+declare class PostgresTableSource extends TableSource {
+  readonly schema: string | undefined;
+  constructor(options: {
+    readonly name: string;
+    readonly schema?: string;
+    readonly alias?: string;
+  });
+  rewrite(rewriter: AstRewriter): AnyFromSource;
+}
+//#endregion
+export { PostgresTableSource as t };
+//# sourceMappingURL=table-source-BvFo7gVs.d.mts.map

package/dist/table-source-BvFo7gVs.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-source-BvFo7gVs.d.mts","names":[],"sources":["../src/core/ast/table-source.ts"],"mappings":";;;cAMa,mBAAA,SAA4B,WAAA;EAAA,SAC9B,MAAA;cAEG,OAAA;IAAA,SACD,IAAA;IAAA,SACA,MAAA;IAAA,SACA,KAAA;EAAA;EAOF,OAAA,CAAQ,QAAA,EAAU,WAAA,GAAc,aAAA;AAAA"}

package/dist/types.d.mts

@@ -1,5 +1,7 @@
+import { t as PostgresTableSource } from "./table-source-BvFo7gVs.mjs";
 import { t as PostgresColumnDefault } from "./types-BDKkx8MA.mjs";
 import { NamespaceBase } from "@prisma-next/framework-components/ir";
+import { CfExpr } from "@prisma-next/sql-relational-core/contract-free";
 import { SqlNamespaceEntries, SqlNamespaceTablesInput, SqlStorage, StorageTable, StorageValueSet } from "@prisma-next/sql-contract/types";
 
 //#region src/core/postgres-schema.d.ts
@@ -65,6 +67,22 @@ declare class PostgresSchema extends NamespaceBase {
    * connection's `search_path` resolved at runtime.
    */
   schemaSqlExpression(): string;
+  /**
+   * Typed-AST counterpart of {@link schemaSqlExpression}: the expression a
+   * builder-built catalog check compares `n.nspname` / `table_schema`
+   * against. Named schemas bind the schema name as a text parameter; the
+   * unbound singleton overrides this to the opaque `current_schema()`
+   * expression so the live connection's `search_path` decides at runtime.
+   */
+  schemaFilterExpression(): CfExpr;
+  /**
+   * Typed-AST counterpart of {@link qualifyTable}: the FROM source a
+   * builder-built check uses to address a user table in this namespace.
+   * Named schemas qualify (`"schema"."table"`); the unbound singleton
+   * overrides this to leave the table unqualified so `search_path`
+   * resolves it at runtime.
+   */
+  tableSource(tableName: string, alias?: string): PostgresTableSource;
   /**
    * The bare schema name a DDL planner should target when emitting
    * statements that need to identify this namespace in the live
@@ -72,9 +90,9 @@ declare class PostgresSchema extends NamespaceBase {
    * catalog filters, planner conflict lookups). Named schemas resolve
    * to their own id. The `PostgresUnboundSchema` singleton inherits
    * this and returns `UNBOUND_NAMESPACE_ID` — callers that dispatch
-   * through `qualifyTableName` / `toRegclassLiteral` route through the
-   * polymorphic `PostgresUnboundSchema` overrides and produce
-   * unqualified (search-path-resolved) output automatically.
+   * through `qualifyTableName` route through the polymorphic
+   * `PostgresUnboundSchema` overrides and produce unqualified
+   * (search-path-resolved) output automatically.
    */
   ddlSchemaName(_storage: SqlStorage): string;
 }
@@ -93,9 +111,9 @@ declare class PostgresSchema extends NamespaceBase {
  * `search_path`).
  *
  * `ddlSchemaName` is inherited from `PostgresSchema` and returns
- * `UNBOUND_NAMESPACE_ID`. Downstream helpers (`qualifyTableName`,
- * `toRegclassLiteral`) route through the polymorphic factory and
- * produce unqualified output automatically.
+ * `UNBOUND_NAMESPACE_ID`. Downstream helpers such as `qualifyTableName`
+ * route through the polymorphic factory and produce unqualified output
+ * automatically.
  */
 declare class PostgresUnboundSchema extends PostgresSchema {
   static readonly instance: PostgresUnboundSchema;
@@ -103,6 +121,8 @@ declare class PostgresUnboundSchema extends PostgresSchema {
   qualifier(): string;
   qualifyTable(tableName: string): string;
   schemaSqlExpression(): string;
+  schemaFilterExpression(): CfExpr;
+  tableSource(tableName: string, alias?: string): PostgresTableSource;
 }
 /**
  * Target-supplied `Namespace` factory the Postgres target plumbs

package/dist/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../src/core/postgres-schema.ts"],"mappings":";;;;;UAiBiB,mBAAA;EAAA,SACN,EAAA;EAAA,SACA,OAAA,EAAS,QAAA,CAAS,MAAA,SAAe,QAAA,CAAS,MAAA;AAAA;;;;;;;;;;;;;;;cAiBxC,cAAA,SAAuB,aAAA;EAjBuB;AAiB3D;;;;;;EAjB2D,OAyBlD,OAAA,EAAS,qBAAA;EAAA,SAEC,IAAA;EAAA,SACR,EAAA;EAAA,SACA,OAAA,EAAS,mBAAA;cAEN,KAAA,EAAO,mBAAA;EAAA,IA4Bf,KAAA,IAAS,QAAA,CAAS,MAAA,SAAe,YAAA;EAAA,IAIjC,QAAA,IAAY,QAAA,CAAS,MAAA,SAAe,eAAA;EA9CN;;;;;EAuDlC,SAAA;EA7CiB;;;;;;EAuDjB,YAAA,CAAa,SAAA;EAvBT;;;;;;EAiCJ,eAAA,CAAgB,IAAA;EA7BwB;;;;;;;;EAyCxC,mBAAA;EAec;;AAAoB;AAwBpC;;;;;;;;EAxBE,aAAA,CAAc,QAAA,EAAU,UAAA;AAAA;;;;;;;;;;AAuCI;AA+B9B;;;;;;;;AAAuF;cA9C1E,qBAAA,SAA8B,cAAA;EAAA,gBACzB,QAAA,EAAU,qBAAA;cAEd,KAAA,GAAQ,mBAAA;EAIX,SAAA;EAIA,YAAA,CAAa,SAAA;EAIb,mBAAA;AAAA;;;;;;;;;;;;iBA+BK,uBAAA,CAAwB,KAAA,EAAO,uBAAA,GAA0B,cAAc"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../src/core/postgres-schema.ts"],"mappings":";;;;;;;UAqBiB,mBAAA;EAAA,SACN,EAAA;EAAA,SACA,OAAA,EAAS,QAAA,CAAS,MAAA,SAAe,QAAA,CAAS,MAAA;AAAA;;;;;;;;;;;;;;;cAiBxC,cAAA,SAAuB,aAAA;EAjBuB;AAiB3D;;;;;;EAjB2D,OAyBlD,OAAA,EAAS,qBAAA;EAAA,SAEC,IAAA;EAAA,SACR,EAAA;EAAA,SACA,OAAA,EAAS,mBAAA;cAEN,KAAA,EAAO,mBAAA;EAAA,IA4Bf,KAAA,IAAS,QAAA,CAAS,MAAA,SAAe,YAAA;EAAA,IAIjC,QAAA,IAAY,QAAA,CAAS,MAAA,SAAe,eAAA;EA+DQ;;;;;EAtDhD,SAAA;EA/CO;;;;;;EAyDP,YAAA,CAAa,SAAA;EAnDM;;;;;;EA6DnB,eAAA,CAAgB,IAAA;EA7BA;;;;;;;;EAyChB,mBAAA;EAWA;;;;;;;EAAA,sBAAA,IAA0B,MAAA;EA8BZ;;AAAoB;AAwBpC;;;;EA3CE,WAAA,CAAY,SAAA,UAAmB,KAAA,YAAiB,mBAAA;EA8Db;;;;;;;;;;;EA3CnC,aAAA,CAAc,QAAA,EAAU,UAAA;AAAA;;;;;;;;;;AA+CoD;AAkC9E;;;;;;;;AAAuF;cAzD1E,qBAAA,SAA8B,cAAA;EAAA,gBACzB,QAAA,EAAU,qBAAA;cAEd,KAAA,GAAQ,mBAAA;EAIX,SAAA;EAIA,YAAA,CAAa,SAAA;EAIb,mBAAA;EAIA,sBAAA,IAA0B,MAAA;EAI1B,WAAA,CAAY,SAAA,UAAmB,KAAA,YAAiB,mBAAA;AAAA;;;;;;;;;;;;iBAkC3C,uBAAA,CAAwB,KAAA,EAAO,uBAAA,GAA0B,cAAc"}

package/dist/types.mjs

@@ -1,2 +1,2 @@
-import { i as postgresCreateNamespace, n as PostgresUnboundSchema, t as PostgresSchema } from "./postgres-schema-CDaLWZwd.mjs";
+import { i as postgresCreateNamespace, n as PostgresUnboundSchema, t as PostgresSchema } from "./postgres-schema-COGZ1ark.mjs";
 export { PostgresSchema, PostgresUnboundSchema, postgresCreateNamespace };