@prisma/orm-family-sql 8.0.0-rc.14-dev.10 → 8.0.0-rc.14-dev.12

package/dist/{ast-BQOF33Tw.d.mts → ast-qnGR-fmK.d.mts}

@@ -1,5 +1,5 @@
 import { E as CodecRef$1, dt as LoweredStatement, h as AnyQueryAst, m as AnyParamRef } from "./types-Yui2yFf6-DQkiEr9B.mjs";
-import { c as SqlQueryable } from "./driver-types-BQtRkOJ0-Bv2RPSfr.mjs";
+import { c as SqlQueryable } from "./driver-types-DYGFEcyv-DPaNalPf.mjs";
 import "./ddl-types-B23QEzDx-ridB7leA.mjs";
 import { ColumnDefaultLiteralInputValue, ContractMarkerRecord, JsonValue } from "@prisma/orm-framework/contract/types";
 import { CodecCallContext, CodecDescriptorTemplateImpl, CodecImpl, CodecInstanceContext, CodecLookupWithDescriptors, DataTypeId, ToCanonicalForm } from "@prisma/orm-framework/components/codec";
@@ -285,4 +285,4 @@ declare function compact<T extends Record<string, unknown>>(o: T): T;
 declare function collectOrderedParamRefs(ast: AnyQueryAst): ReadonlyArray<AnyParamRef>;
 //#endregion
 export { sqlIntDecode as $, canonicalNumeralText as A, parseJsonBody as B, SqlIntCodec as C, SqlVarcharCodec as D, SqlTextDescriptor as E, encodeLiteralDefault as F, sqlCharDescriptor as G, signedRange as H, escapePslString as I, sqlFloatColumn as J, sqlCharEncode as K, integerTextCanonicalForm as L, compact as M, createNumberClassifier as N, SqlVarcharDescriptor as O, encodeListLiteralDefault as P, sqlIntColumn as Q, isNumeralText as R, SqlFloatDescriptor as S, SqlTextCodec as T, sqlCharColumn as U, printJsonBody as V, sqlCharDecode as W, sqlFloatDescriptor as X, sqlFloatDecode as Y, sqlFloatEncode as Z, SQL_TEXT_CODEC_ID as _, DateTimeShape as a, sqlTextEncode as at, SqlCharDescriptor as b, LiteralDefaultColumn as c, sqlVarcharDescriptor as ct, MarkerReadResult as d, sqlIntDescriptor as et, NumberClassification as f, SQL_INT_CODEC_ID as g, SQL_FLOAT_CODEC_ID as h, CanonicalDateTimeOptions as i, sqlTextDescriptor as it, collectOrderedParamRefs as j, canonicalDateTime as k, Lowerer as l, sqlVarcharEncode as lt, SQL_CHAR_CODEC_ID as m, AdapterProfile as n, sqlTextColumn as nt, EncodedLiteralDefault as o, sqlVarcharColumn as ot, NumberClassifierSpec as p, sqlCharRenderOutputType as q, AdapterTarget as r, sqlTextDecode as rt, IntegerStep as s, sqlVarcharDecode as st, Adapter as t, sqlIntEncode as tt, LowererContext as u, sqlVarcharRenderOutputType as ut, SQL_VARCHAR_CODEC_ID as v, SqlIntDescriptor as w, SqlFloatCodec as x, SqlCharCodec as y, numeralText as z };
-//# sourceMappingURL=ast-BQOF33Tw.d.mts.map
+//# sourceMappingURL=ast-qnGR-fmK.d.mts.map

package/dist/{ast-BQOF33Tw.d.mts.map → ast-qnGR-fmK.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"ast-BQOF33Tw.d.mts","names":[],"sources":["../../../../2-sql/4-lanes/relational-core/dist/exports/ast.d.mts"],"mappings":"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"}
+{"version":3,"file":"ast-qnGR-fmK.d.mts","names":[],"sources":["../../../../2-sql/4-lanes/relational-core/dist/exports/ast.d.mts"],"mappings":"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"}

package/dist/builder.d.mts

@@ -1,3 +1,3 @@
-import { o as Expression, x as ScopeField } from "./expression-B95FOcDX.mjs";
-import { T as WhereFilter, _ as SelectQuery, a as DeleteQuery, c as GatedMethod, f as QueryContext, g as Scope, h as ResolveRow, i as Db, l as GroupedQuery, s as Functions, t as AggregateFunctions, u as InsertQuery, v as Subquery, w as UpdateQuery, x as TableProxy } from "./db-DLjWu9-f-BWg-lrGV.mjs";
+import { o as Expression, x as ScopeField } from "./expression-C6yUAU4j.mjs";
+import { T as WhereFilter, _ as SelectQuery, a as DeleteQuery, c as GatedMethod, f as QueryContext, g as Scope, h as ResolveRow, i as Db, l as GroupedQuery, s as Functions, t as AggregateFunctions, u as InsertQuery, v as Subquery, w as UpdateQuery, x as TableProxy } from "./db-DLjWu9-f-B79_8TyU.mjs";
 export type { AggregateFunctions, Db, DeleteQuery, Expression, Functions, GatedMethod, GroupedQuery, InsertQuery, QueryContext, ResolveRow, Scope, ScopeField, SelectQuery, Subquery, TableProxy, UpdateQuery, WhereFilter };

package/dist/builder__runtime.d.mts

@@ -2,9 +2,9 @@ import { c as SqlStorage } from "./sql-storage-BSxD7_vv-C4ugLH39.mjs";
 import "./types-BoMDdzjD.mjs";
 import { i as SqlOperationEntry } from "./index-DrUd8HwS.mjs";
 import { c as AnyExpression } from "./types-Yui2yFf6-DQkiEr9B.mjs";
-import "./ast-BQOF33Tw.mjs";
-import { l as RawCodecInferer, o as Expression, x as ScopeField } from "./expression-B95FOcDX.mjs";
-import { S as TableProxyContract, f as QueryContext, g as Scope, i as Db, o as FieldProxy, p as RawLane, s as Functions, t as AggregateFunctions } from "./db-DLjWu9-f-BWg-lrGV.mjs";
+import "./ast-qnGR-fmK.mjs";
+import { l as RawCodecInferer, o as Expression, x as ScopeField } from "./expression-C6yUAU4j.mjs";
+import { S as TableProxyContract, f as QueryContext, g as Scope, i as Db, o as FieldProxy, p as RawLane, s as Functions, t as AggregateFunctions } from "./db-DLjWu9-f-B79_8TyU.mjs";
 import { a as SqlAggregateDescriptorRegistry, n as ExecutionContext } from "./query-lane-context-BSmWfohZ-QAWw_dXQ.mjs";
 import "./query-lane-context-B0R8L6W-.mjs";
 import { Contract } from "@prisma/orm-framework/contract/types";

package/dist/builder__types.d.mts

@@ -1,3 +1,3 @@
-import { o as Expression, x as ScopeField } from "./expression-B95FOcDX.mjs";
-import { C as UnboundTables, S as TableProxyContract, T as WhereFilter, _ as SelectQuery, a as DeleteQuery, b as TableNamesAcrossNamespaces, c as GatedMethod, d as Namespace, f as QueryContext, g as Scope, h as ResolveRow, i as Db, l as GroupedQuery, m as RawTagFor, n as BooleanCodecType, p as RawLane, r as ContractRawTag, s as Functions, t as AggregateFunctions, u as InsertQuery, v as Subquery, w as UpdateQuery, x as TableProxy, y as TableInAnyNamespace } from "./db-DLjWu9-f-BWg-lrGV.mjs";
+import { o as Expression, x as ScopeField } from "./expression-C6yUAU4j.mjs";
+import { C as UnboundTables, S as TableProxyContract, T as WhereFilter, _ as SelectQuery, a as DeleteQuery, b as TableNamesAcrossNamespaces, c as GatedMethod, d as Namespace, f as QueryContext, g as Scope, h as ResolveRow, i as Db, l as GroupedQuery, m as RawTagFor, n as BooleanCodecType, p as RawLane, r as ContractRawTag, s as Functions, t as AggregateFunctions, u as InsertQuery, v as Subquery, w as UpdateQuery, x as TableProxy, y as TableInAnyNamespace } from "./db-DLjWu9-f-B79_8TyU.mjs";
 export type { AggregateFunctions, BooleanCodecType, ContractRawTag, Db, DeleteQuery, Expression, Functions, GatedMethod, GroupedQuery, InsertQuery, Namespace, QueryContext, RawLane, RawTagFor, ResolveRow, Scope, ScopeField, SelectQuery, Subquery, TableInAnyNamespace, TableNamesAcrossNamespaces, TableProxy, TableProxyContract, UnboundTables, UpdateQuery, WhereFilter };

package/dist/{control-k5_z0qcA.d.mts → control-BFgBjkQh.d.mts}

@@ -1,26 +1,27 @@
 import { t as StorageColumn } from "./storage-table-DSeWszOL-CI-cItEK.mjs";
-import { c as SqlStorage } from "./sql-storage-BSxD7_vv-C4ugLH39.mjs";
+import { a as SqlNamespaceEntries, c as SqlStorage } from "./sql-storage-BSxD7_vv-C4ugLH39.mjs";
 import { O as SqlControlDriverInstance } from "./types-DTUyRqZv-DLh98w8w.mjs";
 import "./types-BoMDdzjD.mjs";
 import { r as SqlOperationDescriptors } from "./index-DrUd8HwS.mjs";
 import { h as AnyQueryAst } from "./types-Yui2yFf6-DQkiEr9B.mjs";
-import { o as SqlExecuteRequest } from "./driver-types-BQtRkOJ0-Bv2RPSfr.mjs";
+import { o as SqlExecuteRequest } from "./driver-types-DYGFEcyv-DPaNalPf.mjs";
 import { s as DdlNode } from "./ddl-types-B23QEzDx-ridB7leA.mjs";
-import { u as LowererContext } from "./ast-BQOF33Tw.mjs";
+import { u as LowererContext } from "./ast-qnGR-fmK.mjs";
 import { t as SQL_EXPRESSION_DATA_TYPE_ID } from "./sql-expression-D_hbJOgM.mjs";
 import "./validators-CZNulH-_.mjs";
 import { _ as SqlSchemaIR, y as SqlSchemaIRNode } from "./types-DinsvYdY-Dv_n3Tac.mjs";
 import "./types-BBT7jidC.mjs";
-import { i as SqlControlAdapter } from "./control-adapter-C4_cgvzB-BwZx3_VD.mjs";
+import { i as SqlControlAdapter } from "./control-adapter-C4_cgvzB-BhRxZg-n.mjs";
 import { t as sqlFamilyEnumSpec } from "./authoring-entity-types-CZ-vdwYS-BCsVtN8A.mjs";
-import { A as SqlPlannerSuccessResult, C as SqlMigrationRunnerSuccessValue, O as SqlPlannerFailureResult, T as SqlPlannerConflict, _ as SqlMigrationRunner, h as SqlMigrationPlanner, n as CodecControlHooks, r as CreateSqlMigrationPlanOptions, t as AnyRecord, u as SqlMigrationPlan, v as SqlMigrationRunnerErrorCode, x as SqlMigrationRunnerFailure } from "./types-BKJWoQ40-BzViF_9K.mjs";
+import { A as SqlPlannerSuccessResult, C as SqlMigrationRunnerSuccessValue, O as SqlPlannerFailureResult, T as SqlPlannerConflict, _ as SqlMigrationRunner, h as SqlMigrationPlanner, n as CodecControlHooks, r as CreateSqlMigrationPlanOptions, t as AnyRecord, u as SqlMigrationPlan, v as SqlMigrationRunnerErrorCode, x as SqlMigrationRunnerFailure } from "./types-BHKZ4M-a-DYsrOHhh.mjs";
 import { t as SqlSchemaDiffFn } from "./schema-differ-DpG_gnur-gLIPLPVI.mjs";
+import { StructuredError } from "@prisma/orm-framework/utils/structured-error";
 import { PresetStorageTemplate, TIMESTAMP_NOW_GENERATOR_ID } from "@prisma/orm-framework/components/authoring";
 import { ColumnDefault, Contract, ControlPolicy } from "@prisma/orm-framework/contract/types";
 import { CodecLookupWithDescriptors, DataType, DataTypeLookup } from "@prisma/orm-framework/components/codec";
 import { TargetBoundComponentDescriptor } from "@prisma/orm-framework/components/components";
 import { AssembledAuthoringContributions, ContractSerializer, ControlFamilyDescriptor, ControlFamilyInstance, ControlStack, DiffSubjectGranularity, MigratableTargetDescriptor, MigrationOperationClass, MigrationOperationPolicy, MigrationOperationPolicy as MigrationOperationPolicy$1, MigrationPlan as MigrationPlan$1, MigrationPlanOperation, MigrationPlanOperation as MigrationPlanOperation$1, MigrationPlanner, MigrationPlannerConflict, MigrationPlannerConflict as MigrationPlannerConflict$1, MigrationPlannerResult, OpFactoryCall, OperationPreview, OperationPreviewCapable, PslContractBuildCapable, PslContractInferCapable, SchemaDiffIssue, SchemaVerifier, SchemaViewCapable, SignDatabaseResult, TargetMigrationsCapability, VerifyDatabaseResult, VerifyDatabaseSchemaResult, assembleAuthoringContributions } from "@prisma/orm-framework/components/control";
-import { NotOk, Ok } from "@prisma/orm-framework/utils/result";
+import { NotOk, Ok, Result } from "@prisma/orm-framework/utils/result";
 import { PslDocumentAst } from "@prisma/orm-framework/components/psl-ast";
 import { EmissionSpi, TypesImportSpec } from "@prisma/orm-framework/components/emission";
 //#region ../../../2-sql/9-family/dist/control.d.mts
@@ -566,6 +567,41 @@ interface SqlControlTargetDescriptor<TTargetId extends string, TTargetDetails, T
   createRunner(family: SqlControlFamilyInstance): SqlMigrationRunner<TTargetDetails>;
 }
 //#endregion
+//#region src/core/migrations/apply-table-rename.d.ts
+/** A table a migration renames: `namespaceId` is `undefined` when the migration leaves the namespace to the contracts. */
+interface TableRename {
+  readonly namespaceId: string | undefined;
+  readonly from: string;
+  readonly to: string;
+}
+/** A rename after its table was found in the start contract. */
+interface ResolvedTableRename {
+  readonly namespaceId: string;
+  readonly from: string;
+  readonly to: string;
+}
+/**
+ * Renames a target's own references to a renamed table inside one namespace's entries: entity kinds the family does not know, such as a target's row-level-security markers, that name a table.
+ */
+type RenameTableReferences = (entries: SqlNamespaceEntries, rename: ResolvedTableRename) => SqlNamespaceEntries;
+interface ApplyTableRenameInput {
+  readonly startContract: Contract<SqlStorage> | null;
+  readonly endContract: Contract<SqlStorage>;
+  readonly rename: TableRename;
+  readonly renameTableReferences: RenameTableReferences | undefined;
+}
+interface AppliedTableRename {
+  /** The start contract with the table under its new name. */
+  readonly contract: Contract<SqlStorage>;
+  readonly rename: ResolvedTableRename;
+}
+/**
+ * Resolves the table a migration renames against its start and end contracts and returns the start contract with that table under its new name, so a diff against the end contract sees the table under one name. The table must exist in the start contract (in exactly one namespace when the namespace is not given), and the new name must exist in the end contract and not in the start contract; otherwise the rename is refused with `MIGRATION.TABLE_RENAME_UNMATCHED`.
+ *
+ * Foreign keys that name the renamed table on either side are retargeted. Index, unique, check and primary-key names are carried unchanged. Target entity kinds that name the table are renamed by the target's `renameTableReferences`.
+ */
+declare function applyTableRename(input: ApplyTableRenameInput): Result<AppliedTableRename, StructuredError>;
+//#endregion
 //#region src/core/migrations/data-type-resolver.d.ts
 /** The data type a codec represents, or `undefined` when no component registers it. */
 type DataTypeResolver = (codecId: string) => DataType | undefined;
@@ -888,6 +924,18 @@ declare const TABLE_NAME_CASE_CHANGED_CODE = "MIGRATION.TABLE_NAME_CASE_CHANGED"
 interface TableNameCaseGuardTable {
   readonly name: string;
 }
+/** A table rename the operator performs by hand, for the target to write the statements of. */
+interface TableRenameByHand {
+  readonly namespaceId: string;
+  readonly from: string;
+  readonly to: string;
+}
+/** A table rename to write as a migration call; `namespaceId` is `undefined` when the call does not need to name the namespace. */
+interface TableRenameInMigration {
+  readonly namespaceId: string | undefined;
+  readonly from: string;
+  readonly to: string;
+}
 /**
  * Finds every (drop `X`, create `Y`) pair in the same namespace where `X` is
  * `Y` with its first letter lowered. That shape is the signature of a schema
@@ -903,6 +951,10 @@ declare function detectTableNameCaseChanges(input: {
   readonly issues: readonly SchemaDiffIssue[];
   readonly tableOf: (issue: SchemaDiffIssue) => TableNameCaseGuardTable | undefined;
   readonly namespaceIdOf: (issue: SchemaDiffIssue) => string;
+  readonly renameByHandStatements: (rename: TableRenameByHand) => readonly string[];
+  readonly renameTableCall: (rename: TableRenameInMigration) => string;
+  readonly contract: Contract<SqlStorage>;
+  readonly defaultNamespaceId: string;
 }): SqlPlannerConflict[];
 //#endregion
 //#region src/core/timestamp-now-generator.d.ts
@@ -1009,5 +1061,5 @@ declare function temporalCodecPresetWithPrecision<const CodecId extends string,
 //#region src/exports/control.d.ts
 declare const _default: SqlFamilyDescriptor;
 //#endregion
-export { contractToSchemaIR as A, plannerSuccess as B, TableNameCaseGuardTable as C, buildDataTypeResolver as D, assembleAuthoringContributions as E, extractCodecControlHooks as F, runnerSuccess as H, partitionCallsByControlPolicy as I, partitionIssuesByControlPolicy as L, createMigrationPlan as M, detectDestructiveChanges as N, buildNativeTypeExpander as O, detectTableNameCaseChanges as P, planFieldEventOperations as R, TABLE_NAME_CASE_CHANGED_CODE as S, _default as T, temporalCodecPresetWithPrecision as U, runnerFailure as V, temporalStringAuthoringPresets as W, SqlControlFamilyInstance as _, DefaultResolver as a, SqlPslBuildContext as b, MigrationOperationClass as c, MigrationPlanOperation$1 as d, MigrationPlanner as f, PlanFieldEventOperationsOptions as g, NativeTypeExpander as h, DefaultRenderer as i, controlPolicyForCall as j, contractNamespaceToSchemaIR as k, MigrationOperationPolicy$1 as l, MigrationPlannerResult as m, ControlPolicySubject as n, EnumNamespaceSchemaResolver as o, MigrationPlannerConflict$1 as p, DataTypeResolver as r, INIT_ADDITIVE_POLICY as s, ContractToSchemaIROptions as t, MigrationPlan$1 as u, SqlControlTargetDescriptor as v, TargetMigrationsCapability as w, SuppressionRecord as x, SqlDescribedContractSpace as y, plannerFailure as z };
-//# sourceMappingURL=control-k5_z0qcA.d.mts.map
+export { TableRenameInMigration as A, createMigrationPlan as B, SqlDescribedContractSpace as C, TableNameCaseGuardTable as D, TABLE_NAME_CASE_CHANGED_CODE as E, buildDataTypeResolver as F, partitionIssuesByControlPolicy as G, detectTableNameCaseChanges as H, buildNativeTypeExpander as I, plannerSuccess as J, planFieldEventOperations as K, contractNamespaceToSchemaIR as L, _default as M, applyTableRename as N, TableRename as O, assembleAuthoringContributions as P, temporalStringAuthoringPresets as Q, contractToSchemaIR as R, SqlControlTargetDescriptor as S, SuppressionRecord as T, extractCodecControlHooks as U, detectDestructiveChanges as V, partitionCallsByControlPolicy as W, runnerSuccess as X, runnerFailure as Y, temporalCodecPresetWithPrecision as Z, NativeTypeExpander as _, DataTypeResolver as a, ResolvedTableRename as b, EnumNamespaceSchemaResolver as c, MigrationOperationPolicy$1 as d, MigrationPlan$1 as f, MigrationPlannerResult as g, MigrationPlannerConflict$1 as h, ControlPolicySubject as i, TargetMigrationsCapability as j, TableRenameByHand as k, INIT_ADDITIVE_POLICY as l, MigrationPlanner as m, ApplyTableRenameInput as n, DefaultRenderer as o, MigrationPlanOperation$1 as p, plannerFailure as q, ContractToSchemaIROptions as r, DefaultResolver as s, AppliedTableRename as t, MigrationOperationClass as u, PlanFieldEventOperationsOptions as v, SqlPslBuildContext as w, SqlControlFamilyInstance as x, RenameTableReferences as y, controlPolicyForCall as z };
+//# sourceMappingURL=control-BFgBjkQh.d.mts.map

package/dist/control-BFgBjkQh.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control-BFgBjkQh.d.mts","names":[],"sources":["../../../../2-sql/9-family/dist/control.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;UAoBU;WACC;WACA;WACA;WACA;;KAEN,0BAA0B,YAAY;UACjC;WACC,kBAAkB,cAAc;WAChC,cAAc;WACd,sBAAsB;;UAEvB,iCAAiC,6BAA6B,kBAAkB,kBAAkB,kBAAkB,wBAAwB,kBAAkB,wBAAwB,SAAS,cAAc,yBAAyB;;;;;;;;;EAS9O,oBAAoB,wBAAwB;EAC5C,OAAO;aACI,QAAQ;aACR;aACA;aACA;aACA;MACP,QAAQ;;;;;;;;;;EAUZ,aAAa;aACF;aACA,QAAQ;aACR;aACA,qBAAqB,cAAc;MAC1C;;;;;;;;;;EAUJ,2BAA2B,OAAO,kBAAkB;;;;;;;;EAQpD,mBAAmB,OAAO;EAC1B,KAAK;aACM,QAAQ;aACR;aACA;aACA;MACP,QAAQ;EACZ,WAAW;aACA,QAAQ;aACR;MACP,QAAQ;EACZ,iBAAiB,UAAU,kBAAkB;EAC7C,SAAS,KAAK,cAAc,SAAS,SAAS,0BAA0B,QAAQ;;;;;;EAMhF,WAAW;aACA,QAAQ;aACR;aACA;eACE;eACA;eACA;;MAET;;;;;EAKJ,aAAa;aACF,QAAQ;aACR;aACA;aACA;eACE;eACA;eACA;;MAET;;;;;EAKJ,iBAAiB;aACN,QAAQ;aACR;aACA;eACE;eACA;eACA;eACA;eACA;eACA;eACA;;MAET;EACJ,yCAAyC;EACzC,mBAAmB,qBAAqB,2BAA6B;;;;cAIzD,+BAA+B,+BAA+B;WACjE;WACA;WACA;WACA;WACA,UAAU;WACV,oBAAoB;WACpB;aACE;eACE;iBACE;iBACA;mBACE;mBACA;mBACA;qBACE;;;;eAIN;iBACE;iBACA;mBACE;mBACA;mBACA;qBACE;;;;eAIN;iBACE;iBACA;mBACE;mBACA;mBACA;qBACE;uBACE;uBACA;uBACA;uBACA;uBACA;;;;iBAIN;mBACE;mBACA;mBACA;qBACE;uBACE;uBACA;uBACA;uBACA;;;;;eAKR;iBACE;iBACA;mBACE;mBACA;mBACA;qBACE;;;;eAIN;iBACE;iBACA;mBACE;mBACA;mBACA;qBACE;;;;eAIN;iBACE;mBACE;mBACA;qBACE;qBACA;qBACA;uBACE;;qBAEF;uBACE;yBACE;yBACA;;;qBAGJ;;;iBAGJ;mBACE;mBACA;qBACE;qBACA;qBACA;uBACE;;qBAEF;uBACE;yBACE;yBACA;;;qBAGJ;;;iBAGJ;mBACE;mBACA;qBACE;qBACA;qBACA;uBACE;;qBAEF;uBACE;yBACE;yBACA;;;qBAGJ;;;iBAGJ;mBACE;mBACA;qBACE;qBACA;qBACA;uBACE;yBACE;yBACA;yBACA;yBACA;yBACA;;;;mBAIN;qBACE;qBACA;qBACA;uBACE;yBACE;yBACA;yBACA;yBACA;;;qBAGJ;uBACE;yBACE;yBACA;yBACA;2BACE;6BACE;6BACA;6BACA;;;;;qBAKR;;;iBAGJ;mBACE;mBACA;qBACE;qBACA;qBACA;uBACE;;qBAEF;uBACE;yBACE;yBACA;;;qBAGJ;;;iBAGJ;mBACE;mBACA;qBACE;qBACA;qBACA;uBACE;;qBAEF;uBACE;yBACE;yBACA;;;qBAGJ;;;;;aAKR;eACE;iBACE;mBACE;mBACA;mBACA;qBACE;qBACA;qBACA;qBACA;qBACA;;mBAEF;qBACE;qBACA;qBACA;uBACE;yBACE;yBACA;;;;;;;aAOZ,gEAAgE;aAChE;eACE;QACP;QACA;QACA;QACA;QACA;UACE;;QAEF,aAAa;QACb;UACE,2CAA2C;YACzC;4CACgC;;;;aAI/B;eACE;iBACE,0CAA0C;UACjD;0CACgC;iBACzB,yCAAyC;UAChD;mBACS;0CACuB;iBACzB,6CAA6C;UACpD;mBACS;0CACuB;iBACzB,4CAA4C;UACnD;mBACS;mBACA;mBACA;mBACA;mBACA;mBACA;mBACA,UAAU;0CACa;iBACzB,4CAA4C;mBAC1C;mBACA;mBACA;0CACuB;iBACzB,8CAA8C;UACrD;0CACgC;iBACzB,oDAAoD;UAC3D;0CACgC;iBACzB,2CAA2C;UAClD,qCAAqC,uDAAuD;UAC5F;0CACgC;;eAE3B;iBACE,0CAA0C;UACjD;0CACgC;iBACzB,yCAAyC;mBACvC;0CACuB;iBACzB,6CAA6C;mBAC3C;0CACuB;iBACzB,8CAA8C;UACrD;UACA;0CACgC;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"}

package/dist/{control-DMbej03E.mjs → control-D7yb7l7O.mjs}

@@ -1,8 +1,8 @@
 import { u as namingOf } from "./naming-Cc_t1q6s-CouBOmqZ.mjs";
 import { t as sqlContractCanonicalizationHooks } from "./canonicalization-hooks-dmXkOR4a.mjs";
-import { c as StorageTable } from "./storage-table-ZzbR-xzQ-C8gXT45E.mjs";
+import { c as StorageTable, n as ForeignKey } from "./storage-table-ZzbR-xzQ-C8gXT45E.mjs";
 import { a as sqlExpressionAuthoringEntry, o as sqlExpressionDataType, r as assertNothingCastsFromSqlExpression, t as SQL_EXPRESSION_DATA_TYPE_ID } from "./sql-expression-BXx0Ilj-.mjs";
-import { u as isStorageTypeInstance } from "./types-BmXzMDQL.mjs";
+import { c as isMaterializedSqlNamespace, o as SqlStorage, u as isStorageTypeInstance } from "./types-BmXzMDQL.mjs";
 import { c as SqlSchemaIR, n as RelationalSchemaNodeKind, u as SqlTableIR } from "./types-C5QzgUrH-B7IJM6qN.mjs";
 import { f as sqlAttributeSpecs } from "./sql-attribute-specs-Bs9QDuS7-DmIRJUz9.mjs";
 import { t as sqlEmission } from "./dist-DeiKZwAD.mjs";
@@ -12,7 +12,7 @@ import { t as sqlFamilyError } from "./errors-B5g0xWro-mWH2C07F.mjs";
 import { t as SqlContractSerializer } from "./sql-contract-serializer-C90xg7_q-DBJSt3MT.mjs";
 import { t as collectSupportedCodecTypeIds } from "./verify-BVk5bjdH-BXgGLM2U.mjs";
 import { TEMPORAL_ON_CREATE_ARG, TEMPORAL_ON_UPDATE_ARG, TIMESTAMP_NOW_GENERATOR_ID, temporalAuthoringPresets, temporalPhaseTemplate } from "@prisma/orm-framework/components/authoring";
-import { isPlainRecord } from "@prisma/orm-framework/components/ir";
+import { UNBOUND_NAMESPACE_ID, isPlainRecord } from "@prisma/orm-framework/components/ir";
 import { InternalError } from "@prisma/orm-framework/utils/internal-error";
 import { effectiveControlPolicy } from "@prisma/orm-framework/contract/types";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
@@ -619,6 +619,118 @@ var SqlFamilyDescriptor = class {
 		return createSqlFamilyInstance(stack);
 	}
 };
+const TABLE_RENAME_UNMATCHED_CODE = "MIGRATION.TABLE_RENAME_UNMATCHED";
+function tableLabel(namespaceId, tableName) {
+	return namespaceId === void 0 || namespaceId === UNBOUND_NAMESPACE_ID ? tableName : `${namespaceId}.${tableName}`;
+}
+function namespacesDeclaring(contract, tableName) {
+	return Object.values(contract.storage.namespaces).filter((namespace) => Object.hasOwn(namespace.entries.table ?? {}, tableName)).map((namespace) => namespace.id);
+}
+function declares(contract, namespaceId, tableName) {
+	return Object.hasOwn(contract.storage.namespaces[namespaceId]?.entries.table ?? {}, tableName);
+}
+function unmatched(rename, reason) {
+	return sqlFamilyError(TABLE_RENAME_UNMATCHED_CODE, `renameTable "${tableLabel(rename.namespaceId, rename.from)}" to "${rename.to}" does not match the migration's contracts: ${reason}.`, {
+		why: "renameTable must name a table of the migration's start contract and a new name that the end contract has and the start contract does not. Make the rename its own schema change, so the migration's start contract is the schema before the rename and its end contract the schema after it, and check the spelling and the namespace.",
+		meta: {
+			from: rename.from,
+			to: rename.to
+		}
+	});
+}
+function resolveTableRename(rename, startContract, endContract) {
+	const namespaceIds = rename.namespaceId === void 0 ? namespacesDeclaring(startContract, rename.from) : declares(startContract, rename.namespaceId, rename.from) ? [rename.namespaceId] : [];
+	const [namespaceId, ...others] = namespaceIds;
+	if (namespaceId === void 0) return notOk(unmatched(rename, `table "${tableLabel(rename.namespaceId, rename.from)}" does not exist in the start contract`));
+	if (others.length > 0) return notOk(unmatched(rename, `table "${rename.from}" is declared in more than one namespace (${namespaceIds.join(", ")}); name its namespace`));
+	if (declares(startContract, namespaceId, rename.to)) return notOk(unmatched(rename, `table "${tableLabel(namespaceId, rename.to)}" already exists in the start contract`));
+	if (!declares(endContract, namespaceId, rename.to)) return notOk(unmatched(rename, `table "${tableLabel(namespaceId, rename.to)}" does not exist in the end contract`));
+	return ok({
+		namespaceId,
+		from: rename.from,
+		to: rename.to
+	});
+}
+function renamedReference(reference, rename) {
+	if (!(reference.spaceId === void 0) || reference.namespaceId !== rename.namespaceId || reference.tableName !== rename.from) return reference;
+	return {
+		...reference,
+		tableName: rename.to
+	};
+}
+function renameForeignKeys(table, rename) {
+	if (!table.foreignKeys.some((fk) => renamedReference(fk.source, rename) !== fk.source || renamedReference(fk.target, rename) !== fk.target)) return table;
+	return new StorageTable({
+		...table,
+		foreignKeys: table.foreignKeys.map((fk) => new ForeignKey({
+			...fk,
+			source: renamedReference(fk.source, rename),
+			target: renamedReference(fk.target, rename)
+		}))
+	});
+}
+/**
+* The same namespace instance with only `entries` replaced: every own
+* property, including the non-enumerable `kind`, is carried over onto the
+* same prototype, so the target's namespace class (its `qualifyTable`,
+* `ddlSchemaName`, entity getters) keeps working on the copy. This is the
+* one place a frozen contract node is rebuilt without its constructor: the
+* constructors re-hydrate `entries` from raw input, which the already
+* hydrated entities here do not need.
+*/
+function withEntries(namespace, entries) {
+	const copy = Object.create(Object.getPrototypeOf(namespace), {
+		...Object.getOwnPropertyDescriptors(namespace),
+		entries: {
+			value: Object.freeze(entries),
+			enumerable: true,
+			writable: false,
+			configurable: false
+		}
+	});
+	return Object.freeze(copy);
+}
+function renameTableInNamespace(namespace, rename, renameTableReferences) {
+	const ownsTable = rename.namespaceId === namespace.id;
+	const tables = Object.entries(namespace.entries.table ?? {}).map(([name, table]) => [ownsTable && name === rename.from ? rename.to : name, renameForeignKeys(table, rename)]);
+	if (tables.every(([name, table]) => namespace.entries.table?.[name] === table)) return namespace;
+	if (!isMaterializedSqlNamespace(namespace)) throw new InternalError(`applyTableRename: namespace "${namespace.id}" is not a materialized SQL namespace`);
+	const renamedTables = {
+		...namespace.entries,
+		table: Object.fromEntries(tables)
+	};
+	return withEntries(namespace, renameTableReferences === void 0 || !ownsTable ? renamedTables : renameTableReferences(renamedTables, rename));
+}
+function renameTableInContract(contract, rename, renameTableReferences) {
+	const namespaces = Object.fromEntries(Object.entries(contract.storage.namespaces).map(([id, namespace]) => [id, renameTableInNamespace(namespace, rename, renameTableReferences)]));
+	const materialized = {};
+	for (const [id, namespace] of Object.entries(namespaces)) {
+		if (!isMaterializedSqlNamespace(namespace)) throw new InternalError(`applyTableRename: namespace "${id}" is not a materialized SQL namespace`);
+		materialized[id] = namespace;
+	}
+	return {
+		...contract,
+		storage: new SqlStorage({
+			storageHash: contract.storage.storageHash,
+			...contract.storage.types === void 0 ? {} : { types: contract.storage.types },
+			namespaces: materialized
+		})
+	};
+}
+/**
+* Resolves the table a migration renames against its start and end contracts and returns the start contract with that table under its new name, so a diff against the end contract sees the table under one name. The table must exist in the start contract (in exactly one namespace when the namespace is not given), and the new name must exist in the end contract and not in the start contract; otherwise the rename is refused with `MIGRATION.TABLE_RENAME_UNMATCHED`.
+*
+* Foreign keys that name the renamed table on either side are retargeted. Index, unique, check and primary-key names are carried unchanged. Target entity kinds that name the table are renamed by the target's `renameTableReferences`.
+*/
+function applyTableRename(input) {
+	if (input.startContract === null) return notOk(unmatched(input.rename, "the migration has no start contract"));
+	const resolved = resolveTableRename(input.rename, input.startContract, input.endContract);
+	if (!resolved.ok) return resolved;
+	return ok({
+		contract: renameTableInContract(input.startContract, resolved.value, input.renameTableReferences),
+		rename: resolved.value
+	});
+}
 function convertColumn(name, column, storageTypes, expandNativeType, renderDefault, resolveDefault, dataTypeOf) {
 	const resolved = resolveColumnTypeMetadata(column, storageTypes);
 	const baseNativeType = expandNativeType ? expandNativeType({
@@ -1311,6 +1423,11 @@ function plannedTable(node, namespaceId) {
 		tableName: node.name
 	};
 }
+function renameNeedsNamespace(drop, dropped, contract, defaultNamespaceId) {
+	if (drop.namespaceId !== UNBOUND_NAMESPACE_ID && drop.namespaceId !== defaultNamespaceId) return true;
+	const declaredElsewhere = (namespaceId, tableName) => namespaceId !== drop.namespaceId && tableName === drop.tableName;
+	return dropped.some((other) => declaredElsewhere(other.namespaceId, other.tableName)) || Object.values(contract.storage.namespaces).some((namespace) => Object.keys(namespace.entries.table ?? {}).some((tableName) => declaredElsewhere(namespace.id, tableName)));
+}
 /**
 * Finds every (drop `X`, create `Y`) pair in the same namespace where `X` is
 * `Y` with its first letter lowered. That shape is the signature of a schema
@@ -1336,10 +1453,19 @@ function detectTableNameCaseChanges(input) {
 	for (const create of created) {
 		const drop = dropped.find((candidate) => candidate.namespaceId === create.namespaceId && candidate.tableName === lowerFirst(create.tableName));
 		if (drop === void 0) continue;
+		const renameCall = input.renameTableCall({
+			namespaceId: renameNeedsNamespace(drop, dropped, input.contract, input.defaultNamespaceId) ? drop.namespaceId : void 0,
+			from: drop.tableName,
+			to: create.tableName
+		});
 		conflicts.push({
 			kind: "tableNameCaseChanged",
 			summary: `${TABLE_NAME_CASE_CHANGED_CODE}: table "${create.tableName}" would be created and table "${drop.tableName}" dropped. Prisma 8 changed the default table name: a model with no @@map now names its table verbatim, so model ${create.tableName} points at "${create.tableName}" instead of "${drop.tableName}".`,
-			why: `To keep table "${drop.tableName}" and its rows, add @@map("${drop.tableName}") to model ${create.tableName} (or run the add-model-map codemod over the schema) and plan again. Prisma 8 has no rename-table operation, so a deliberate rename is done by hand: run ALTER TABLE "${drop.tableName}" RENAME TO "${create.tableName}" (schema-qualified where applicable), after which the plan is empty.`,
+			why: `To keep table "${drop.tableName}" and its rows, add @@map("${drop.tableName}") to model ${create.tableName} (or run the add-model-map codemod over the schema) and plan again. To rename the table and keep its rows instead: in a project with migration history, make the rename its own schema change, create its migration with prisma migration new --from <hash of the migration the database is at>, and add ${renameCall} to the migration's operations, which renames the table and the objects named after it; in a project that uses db update, rename it by hand with ${input.renameByHandStatements({
+				namespaceId: create.namespaceId,
+				from: drop.tableName,
+				to: create.tableName
+			}).join("; ")}, then run db update again.`,
 			location: {
 				namespaceId: create.namespaceId,
 				entityKind: "table",
@@ -1403,6 +1529,6 @@ function temporalCodecPresetWithPrecision(input) {
 }
 var control_default = new SqlFamilyDescriptor();
 //#endregion
-export { plannerSuccess as _, buildNativeTypeExpander as a, temporalCodecPresetWithPrecision as b, controlPolicyForCall as c, detectDestructiveChanges as d, detectTableNameCaseChanges as f, plannerFailure as g, planFieldEventOperations as h, buildDataTypeResolver as i, control_default as l, partitionIssuesByControlPolicy as m, TABLE_NAME_CASE_CHANGED_CODE as n, contractNamespaceToSchemaIR as o, partitionCallsByControlPolicy as p, assembleAuthoringContributions as r, contractToSchemaIR as s, INIT_ADDITIVE_POLICY as t, createMigrationPlan as u, runnerFailure as v, temporalStringAuthoringPresets as x, runnerSuccess as y };
+export { temporalStringAuthoringPresets as S, plannerFailure as _, buildDataTypeResolver as a, runnerSuccess as b, contractToSchemaIR as c, createMigrationPlan as d, detectDestructiveChanges as f, planFieldEventOperations as g, partitionIssuesByControlPolicy as h, assembleAuthoringContributions as i, controlPolicyForCall as l, partitionCallsByControlPolicy as m, TABLE_NAME_CASE_CHANGED_CODE as n, buildNativeTypeExpander as o, detectTableNameCaseChanges as p, applyTableRename as r, contractNamespaceToSchemaIR as s, INIT_ADDITIVE_POLICY as t, control_default as u, plannerSuccess as v, temporalCodecPresetWithPrecision as x, runnerFailure as y };
 
-//# sourceMappingURL=control-DMbej03E.mjs.map
+//# sourceMappingURL=control-D7yb7l7O.mjs.map