@prisma/orm-family-sql 8.0.0-rc.2-dev.3 → 8.0.0-rc.20-dev.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"control-ChAUdOOu.d.mts","names":[],"sources":["../../../../2-sql-family/9-family/dist/control.d.mts"],"mappings":"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"}

package/dist/{control-adapter-C99J7aEF-B7eQd7vD.d.mts → control-adapter-Bn0uhplA-BzP2uPqJ.d.mts}

@@ -1,31 +1,14 @@
-import { O as SqlControlDriverInstance } from "./types-BDUG29Df-LE85dIXP.mjs";
-import "./types-UcHa2cTe.mjs";
-import { m as AnyQueryAst, ut as LoweredStatement } from "./types-v3qxLLxo-DCeKv7yY.mjs";
-import { o as SqlExecuteRequest } from "./driver-types-BQtRkOJ0-Bv2RPSfr.mjs";
-import { s as DdlNode } from "./ddl-types-CXx4vPz6-BsgrnSUY.mjs";
-import { a as LowererContext } from "./ast-HFcfQZr-.mjs";
-import { v as SqlSchemaIRNode } from "./types-YStFFkKs-D9UAmnON.mjs";
-import "./types-Dwcw0F8X.mjs";
-import { ColumnDefault, ContractMarkerRecord, LedgerEntryRecord } from "@prisma/orm-framework/contract/types";
+import { j as SqlControlDriverInstance } from "./types-DfKvtJwS-CrpWTGBJ.mjs";
+import "./types-CkAd8SWm.mjs";
+import { gt as LoweredStatement, h as AnyQueryAst } from "./types-DriMIMNQ-BkbsW7w3.mjs";
+import { o as SqlExecuteRequest } from "./driver-types-DRsYeq3j-BimeCnUk.mjs";
+import { a as DdlNode, r as DdlColumn } from "./ddl-types-By5mT2_S-CdaaFvsX.mjs";
+import { p as LowererContext } from "./ast-YEMe_B8z.mjs";
+import { S as SqlSchemaIRNode } from "./types-CuCxAQat-Dz8P4xyt.mjs";
+import "./types-ljUNyiWe.mjs";
+import { ContractMarkerRecord, LedgerEntryRecord } from "@prisma/orm-framework/contract/types";
 import { ControlAdapterInstance, ControlStack } from "@prisma/orm-framework/components/control";
-//#region ../../../2-sql/9-family/dist/control-adapter-C99J7aEF.d.mts
-//#region src/core/diff/sql-schema-diff.d.ts
-/**
- * Function type for normalizing raw database default expressions into ColumnDefault.
- * Target-specific implementations handle database dialect differences.
- */
-type DefaultNormalizer = (rawDefault: string, nativeType: string) => ColumnDefault | undefined;
-/**
- * Function type for normalizing schema native types to canonical form for comparison.
- * Target-specific implementations handle dialect-specific type name variations
- * (e.g., Postgres 'varchar' → 'character varying', 'timestamptz' normalization).
- */
-type NativeTypeNormalizer = (nativeType: string) => string;
-/**
- * Compares two arrays of strings for equality (order-sensitive).
- */
-declare function arraysEqual(a: readonly string[], b: readonly string[]): boolean;
-//#endregion
+//#region ../../../2-sql-family/9-family/dist/control-adapter-Bn0uhplA.d.mts
 //#region src/core/control-adapter.d.ts
 /**
  * Structural interface for anything that can lower a SQL/DDL AST node to a
@@ -45,6 +28,10 @@ interface Lowerer {
  */
 interface ExecuteRequestLowerer extends Lowerer {
   lowerToExecuteRequest(ast: AnyQueryAst | DdlNode, context?: LowererContext<unknown>): Promise<SqlExecuteRequest>;
+  /**
+   * The `DEFAULT …` clause DDL writes for `column`'s default, or `''` when it has none or writes it another way, as an autoincrement column does. A literal default, and each element of a list default, is read by the column's codec first, so a value the codec refuses is `CONTRACT.DEFAULT_INVALID` naming `table` and the column. Every DDL statement that writes a column default writes this clause.
+   */
+  renderColumnDefault(column: DdlColumn, table: string): Promise<string>;
 }
 /**
  * SQL control adapter interface for control-plane operations.
@@ -84,9 +71,9 @@ interface SqlControlAdapter<TTarget extends string = string> extends ControlAdap
   readLedger(driver: SqlControlDriverInstance<TTarget>, space?: string): Promise<readonly LedgerEntryRecord[]>;
   /**
    * Inserts the initial marker row for `space` (`INSERT` only). Fails when a
-   * row for that space already exists. Used by `sign()` so concurrent first-time
+   * row for that space already exists. Used by `signSpaces()` so concurrent first-time
    * stamps cannot silently overwrite each other. `updated_at` is DB-side
-   * (`now()` / `datetime('now')`). Mirrors `MongoControlAdapter.initMarker`.
+   * (`now()` / `strftime('%Y-%m-%dT%H:%M:%fZ','now')`). Mirrors `MongoControlAdapter.initMarker`.
    */
   insertMarker(driver: SqlControlDriverInstance<TTarget>, space: string, destination: {
     readonly storageHash: string;
@@ -97,7 +84,7 @@ interface SqlControlAdapter<TTarget extends string = string> extends ControlAdap
    * Writes the initial marker row for `space` as an upsert (`INSERT … ON
    * CONFLICT (space) DO UPDATE SET …`), so re-stamping a space overwrites the
    * existing row rather than failing. `updated_at` is stamped with a DB-side
-   * time expression (`now()` / `datetime('now')`), never an app-side clock.
+   * time expression (`now()` / `strftime('%Y-%m-%dT%H:%M:%fZ','now')`), never an app-side clock.
    */
   initMarker(driver: SqlControlDriverInstance<TTarget>, space: string, destination: {
     readonly storageHash: string;
@@ -131,6 +118,14 @@ interface SqlControlAdapter<TTarget extends string = string> extends ControlAdap
     readonly operations: readonly unknown[];
     readonly destinationContractJson?: unknown;
   }): Promise<void>;
+  /**
+   * Runs `fn` in one transaction on `driver`: `BEGIN`, then `COMMIT` when `fn` resolves, or `ROLLBACK` and the error rethrown when it throws. The driver must send `BEGIN`, every statement `fn` sends through it and the final `COMMIT` or `ROLLBACK` over one database session; the Postgres and SQLite control drivers each hold one connection.
+   */
+  withTransaction<T>(driver: SqlControlDriverInstance<TTarget>, fn: () => Promise<T>): Promise<T>;
+  /**
+   * Inside a transaction `withTransaction` opened, takes the one lock the migration runner holds while it reads and writes markers, and holds it until the transaction ends. The lock covers the marker table, so it is the same for every space. A target whose `withTransaction` already takes a lock that excludes the runner does nothing here.
+   */
+  lockMarker(driver: SqlControlDriverInstance<TTarget>): Promise<void>;
   /**
    * Introspects a database schema and returns the target's schema-IR node.
    *
@@ -149,18 +144,6 @@ interface SqlControlAdapter<TTarget extends string = string> extends ControlAdap
    * @returns Promise resolving to the live database schema node
    */
   introspect(driver: SqlControlDriverInstance<TTarget>, contract?: unknown, schema?: string): Promise<SqlSchemaIRNode>;
-  /**
-   * Optional target-specific normalizer for raw database default expressions.
-   * When provided, schema defaults (raw strings) are normalized before comparison
-   * with contract defaults (ColumnDefault objects) during schema verification.
-   */
-  readonly normalizeDefault?: DefaultNormalizer;
-  /**
-   * Optional target-specific normalizer for schema native type names.
-   * When provided, schema native types (from introspection) are normalized
-   * before comparison with contract native types during schema verification.
-   */
-  readonly normalizeNativeType?: NativeTypeNormalizer;
   /**
    * Ordered DDL queries that bootstrap marker/ledger control tables for migration
    * runners. Postgres includes `CREATE SCHEMA`; SQLite does not.
@@ -188,5 +171,5 @@ interface SqlControlAdapterDescriptor<TTarget extends string = string> {
   create(stack: ControlStack<'sql', TTarget>): SqlControlAdapter<TTarget>;
 }
 //#endregion
-export { SqlControlAdapterDescriptor as a, SqlControlAdapter as i, Lowerer as n, arraysEqual as o, NativeTypeNormalizer as r, ExecuteRequestLowerer as t };
-//# sourceMappingURL=control-adapter-C99J7aEF-B7eQd7vD.d.mts.map
+export { SqlControlAdapterDescriptor as i, Lowerer as n, SqlControlAdapter as r, ExecuteRequestLowerer as t };
+//# sourceMappingURL=control-adapter-Bn0uhplA-BzP2uPqJ.d.mts.map

package/dist/control-adapter-Bn0uhplA-BzP2uPqJ.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control-adapter-Bn0uhplA-BzP2uPqJ.d.mts","names":[],"sources":["../../../../2-sql-family/9-family/dist/control-adapter-Bn0uhplA.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;UAaU;EACR,MAAM,KAAK,cAAc,SAAS,SAAS,0BAA0B;;;;;;;;UAQ7D,8BAA8B;EACtC,sBAAsB,KAAK,cAAc,SAAS,UAAU,0BAA0B,QAAQ;;;;EAI9F,oBAAoB,QAAQ,WAAW,gBAAgB;;;;;;;;UAQ/C,kBAAkB,yCAAyC,8BAA8B,UAAU;;;;;;;;;;;;;;;;EAgB3G,WAAW,QAAQ,yBAAyB,UAAU,gBAAgB,QAAQ;;;;;;;;EAQ9E,eAAe,QAAQ,yBAAyB,WAAW,QAAQ,oBAAoB;;;;;EAKvF,WAAW,QAAQ,yBAAyB,UAAU,iBAAiB,iBAAiB;;;;;;;EAOxF,aAAa,QAAQ,yBAAyB,UAAU,eAAe;aAC5D;aACA;aACA;MACP;;;;;;;EAOJ,WAAW,QAAQ,yBAAyB,UAAU,eAAe;aAC1D;aACA;aACA;MACP;;;;;;;;EAQJ,aAAa,QAAQ,yBAAyB,UAAU,eAAe,sBAAsB;aAClF;aACA;aACA;MACP;;;;;;;EAOJ,iBAAiB,QAAQ,yBAAyB,UAAU,eAAe;aAChE;aACA;aACA;aACA;aACA;aACA;aACA;MACP;;;;EAIJ,gBAAgB,GAAG,QAAQ,yBAAyB,UAAU,UAAU,QAAQ,KAAK,QAAQ;;;;EAI7F,WAAW,QAAQ,yBAAyB,WAAW;;;;;;;;;;;;;;;;;;EAkBvD,WAAW,QAAQ,yBAAyB,UAAU,oBAAoB,kBAAkB,QAAQ;;;;;EAKpG,yCAAyC;;;;;EAKzC,uCAAuC;;;;;;;;UAQ/B,4BAA4B;;;;;;;EAOpC,OAAO,OAAO,oBAAoB,WAAW,kBAAkB"}

package/dist/control-adapter-NZ2kKc4x.d.mts

@@ -0,0 +1,13 @@
+import { d as SqlColumnIRInput, i as ReportedSqlType } from "./types-CuCxAQat-Dz8P4xyt.mjs";
+import "./types-ljUNyiWe.mjs";
+import "./control-adapter-Bn0uhplA-BzP2uPqJ.mjs";
+import { DataType } from "@prisma/orm-framework/components/codec";
+//#region ../../../2-sql-family/9-family/dist/control-adapter.d.mts
+//#region src/core/resolve-introspected-types.d.ts
+/**
+ * The type an introspected column is stored as: the data type that claims its reported type, with its parameters in normal form, over `dataTypes`, the stack's declared data types in assembly order. Empty when no data type claims it. Each adapter spreads it into the column it builds. ADR 254.
+ */
+declare function resolveIntrospectedColumnType(reported: ReportedSqlType, dataTypes: readonly DataType[]): Pick<SqlColumnIRInput, 'storedType' | 'storedTypeParams'>;
+//#endregion
+export { resolveIntrospectedColumnType as t };
+//# sourceMappingURL=control-adapter-NZ2kKc4x.d.mts.map

package/dist/control-adapter-NZ2kKc4x.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control-adapter-NZ2kKc4x.d.mts","names":[],"sources":["../../../../2-sql-family/9-family/dist/control-adapter.d.mts"],"mappings":";;;;;;;;;iBAOiB,8BAA8B,UAAU,iBAAiB,oBAAoB,aAAa,KAAK"}

package/dist/control-adapter-SlQkTEwT.mjs

@@ -0,0 +1,16 @@
+import { o as resolveReportedSqlType } from "./sql-data-type-D7M-YTTY-D2vRqDxn.mjs";
+//#region ../../../2-sql-family/9-family/dist/control-adapter.mjs
+/**
+* The type an introspected column is stored as: the data type that claims its reported type, with its parameters in normal form, over `dataTypes`, the stack's declared data types in assembly order. Empty when no data type claims it. Each adapter spreads it into the column it builds. ADR 254.
+*/
+function resolveIntrospectedColumnType(reported, dataTypes) {
+	const resolved = resolveReportedSqlType(reported, dataTypes);
+	return resolved === void 0 ? {} : {
+		storedType: resolved.dataType,
+		storedTypeParams: resolved.typeParams
+	};
+}
+//#endregion
+export { resolveIntrospectedColumnType as t };
+
+//# sourceMappingURL=control-adapter-SlQkTEwT.mjs.map

package/dist/control-adapter-SlQkTEwT.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"control-adapter-SlQkTEwT.mjs","names":[],"sources":["../../../../2-sql-family/9-family/dist/control-adapter.mjs"],"sourcesContent":["import { resolveReportedSqlType } from \"@internal/sql-contract/data-type\";\n//#region src/core/resolve-introspected-types.ts\n/**\n* The type an introspected column is stored as: the data type that claims its reported type, with its parameters in normal form, over `dataTypes`, the stack's declared data types in assembly order. Empty when no data type claims it. Each adapter spreads it into the column it builds. ADR 254.\n*/\nfunction resolveIntrospectedColumnType(reported, dataTypes) {\n\tconst resolved = resolveReportedSqlType(reported, dataTypes);\n\treturn resolved === void 0 ? {} : {\n\t\tstoredType: resolved.dataType,\n\t\tstoredTypeParams: resolved.typeParams\n\t};\n}\n//#endregion\nexport { resolveIntrospectedColumnType };\n\n//# sourceMappingURL=control-adapter.mjs.map"],"mappings":";;;;;AAKA,SAAS,8BAA8B,UAAU,WAAW;CAC3D,MAAM,WAAW,uBAAuB,UAAU,SAAS;CAC3D,OAAO,aAAa,KAAK,IAAI,CAAC,IAAI;EACjC,YAAY,SAAS;EACrB,kBAAkB,SAAS;CAC5B;AACD"}

package/dist/data-type-BFSpaotu.mjs

@@ -0,0 +1,52 @@
+import { f as sqlDataType } from "./sql-data-type-D7M-YTTY-D2vRqDxn.mjs";
+import { structuredError } from "@prisma/orm-framework/utils/structured-error";
+import { dataTypeId } from "@prisma/orm-framework/components/codec";
+import { type } from "arktype";
+//#region ../../../2-sql-family/1-core/contract/dist/data-type.mjs
+const SQL_RAW_DATA_TYPE_ID = dataTypeId("sql/raw");
+const NAME = `(?:[A-Za-z0-9_]+|"(?:[^"]|"")+")`;
+const TOKEN = `${NAME}(?:\\((?:[A-Za-z0-9_, ]|-(?=[0-9]))*\\))?`;
+/**
+* The texts a raw type may be: words and double-quoted names, with each double quote inside doubled, separated by single spaces, the first
+* optionally after one schema name and a dot, each optionally followed by parentheses holding only
+* letters, digits, underscores, commas, spaces and a minus sign before a digit, then at most one
+* `[]`. Postgres prints a schema only for a type off the `search_path` that is not a base type.
+*/
+const RAW_TYPE_TEXT = new RegExp(`^(?:${NAME}\\.)?${TOKEN}(?: ${TOKEN})*(?:\\[\\])?$`);
+/** Returns undefined when `text` may be written as a column's type, else the reason. */
+function checkRawTypeText(text) {
+	return RAW_TYPE_TEXT.test(text) ? void 0 : "A raw type is one type name as the database catalog prints it, such as tsvector, double precision, geometry(Point,4326), app.email or \"MyType\"[]: words of letters, digits and underscores separated by single spaces, or double-quoted names with each double quote inside doubled; the first optionally after one schema name and a dot; each optionally followed by parentheses holding only letters, digits, underscores, commas, spaces and a minus sign before a digit; and at most one trailing [].";
+}
+const sqlRawParams = type({ sql: "string" }).narrow((params, ctx) => {
+	const refused = checkRawTypeText(params.sql);
+	return refused === void 0 || ctx.reject({
+		path: ["sql"],
+		message: refused
+	});
+});
+/**
+* The refusal of a literal value of a raw column, which has none: Prisma does not interpret a raw
+* column's values. Every literal reaches it through the data type's reader.
+*/
+function refuseLiteralValue() {
+	throw structuredError("CONTRACT.LITERAL_VALUES_ABSENT", "A raw column has no literal values, so its default cannot be a literal. Write the default as a SQL expression: sql`...`.", {
+		why: "Prisma does not interpret the values of a raw column, so it cannot write or compare a literal of its type.",
+		fix: "Write the default as a sql expression, such as @default(sql`...`) in a schema or .default(sql`...`) in TypeScript."
+	});
+}
+/**
+* The data type of a column whose type no other data type claims. Its `sql` parameter is the type
+* exactly as the database catalog prints it, which migrations write and verify compares. It claims
+* no reported type, so introspection never reads a column as raw. It has no literal values: it
+* declares no casts, and its reader refuses every value. ADR 273.
+*/
+const sqlRawDataType = sqlDataType(SQL_RAW_DATA_TYPE_ID, {
+	params: sqlRawParams,
+	nameIsCatalogText: true,
+	render: ({ sql }) => sql,
+	read: refuseLiteralValue
+});
+//#endregion
+export { checkRawTypeText as n, sqlRawDataType as r, SQL_RAW_DATA_TYPE_ID as t };
+
+//# sourceMappingURL=data-type-BFSpaotu.mjs.map

package/dist/data-type-BFSpaotu.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-type-BFSpaotu.mjs","names":[],"sources":["../../../../2-sql-family/1-core/contract/dist/data-type.mjs"],"sourcesContent":["import { _ as unquotedSqlBaseName, a as renderSqlTypeName, c as sameSqlColumnType, d as sqlColumnLength, f as sqlDataType, g as sqlStorageTypeOfCodec, h as sqlStorageTypeId, i as renderSqlCatalogText, l as sqlBaseName, m as sqlStorageType, n as isSqlDataType, o as resolveReportedSqlType, p as sqlDataTypeOfCodec, r as nameIsCatalogText, s as resolveWrittenSqlTypes, t as findSqlDataTypeCollision, u as sqlCodecColumnLength, v as unquotedSqlBaseNameOfCodec, y as validateSqlTypeParams } from \"./sql-data-type-D7M-YTTY.mjs\";\nimport { structuredError } from \"@internal/utils/structured-error\";\nimport { dataTypeId } from \"@internal/framework-components/codec\";\nimport { type } from \"arktype\";\n//#region src/sql-raw.ts\nconst SQL_RAW_DATA_TYPE_ID = dataTypeId(\"sql/raw\");\nconst NAME = `(?:[A-Za-z0-9_]+|\"(?:[^\"]|\"\")+\")`;\nconst TOKEN = `${NAME}(?:\\\\((?:[A-Za-z0-9_, ]|-(?=[0-9]))*\\\\))?`;\n/**\n* The texts a raw type may be: words and double-quoted names, with each double quote inside doubled, separated by single spaces, the first\n* optionally after one schema name and a dot, each optionally followed by parentheses holding only\n* letters, digits, underscores, commas, spaces and a minus sign before a digit, then at most one\n* `[]`. Postgres prints a schema only for a type off the `search_path` that is not a base type.\n*/\nconst RAW_TYPE_TEXT = new RegExp(`^(?:${NAME}\\\\.)?${TOKEN}(?: ${TOKEN})*(?:\\\\[\\\\])?$`);\n/** Returns undefined when `text` may be written as a column's type, else the reason. */\nfunction checkRawTypeText(text) {\n\treturn RAW_TYPE_TEXT.test(text) ? void 0 : \"A raw type is one type name as the database catalog prints it, such as tsvector, double precision, geometry(Point,4326), app.email or \\\"MyType\\\"[]: words of letters, digits and underscores separated by single spaces, or double-quoted names with each double quote inside doubled; the first optionally after one schema name and a dot; each optionally followed by parentheses holding only letters, digits, underscores, commas, spaces and a minus sign before a digit; and at most one trailing [].\";\n}\nconst sqlRawParams = type({ sql: \"string\" }).narrow((params, ctx) => {\n\tconst refused = checkRawTypeText(params.sql);\n\treturn refused === void 0 || ctx.reject({\n\t\tpath: [\"sql\"],\n\t\tmessage: refused\n\t});\n});\n/**\n* The refusal of a literal value of a raw column, which has none: Prisma does not interpret a raw\n* column's values. Every literal reaches it through the data type's reader.\n*/\nfunction refuseLiteralValue() {\n\tthrow structuredError(\"CONTRACT.LITERAL_VALUES_ABSENT\", \"A raw column has no literal values, so its default cannot be a literal. Write the default as a SQL expression: sql`...`.\", {\n\t\twhy: \"Prisma does not interpret the values of a raw column, so it cannot write or compare a literal of its type.\",\n\t\tfix: \"Write the default as a sql expression, such as @default(sql`...`) in a schema or .default(sql`...`) in TypeScript.\"\n\t});\n}\n/**\n* The data type of a column whose type no other data type claims. Its `sql` parameter is the type\n* exactly as the database catalog prints it, which migrations write and verify compares. It claims\n* no reported type, so introspection never reads a column as raw. It has no literal values: it\n* declares no casts, and its reader refuses every value. ADR 273.\n*/\nconst sqlRawDataType = sqlDataType(SQL_RAW_DATA_TYPE_ID, {\n\tparams: sqlRawParams,\n\tnameIsCatalogText: true,\n\trender: ({ sql }) => sql,\n\tread: refuseLiteralValue\n});\n//#endregion\nexport { SQL_RAW_DATA_TYPE_ID, checkRawTypeText, findSqlDataTypeCollision, isSqlDataType, nameIsCatalogText, renderSqlCatalogText, renderSqlTypeName, resolveReportedSqlType, resolveWrittenSqlTypes, sameSqlColumnType, sqlBaseName, sqlCodecColumnLength, sqlColumnLength, sqlDataType, sqlDataTypeOfCodec, sqlRawDataType, sqlStorageType, sqlStorageTypeId, sqlStorageTypeOfCodec, unquotedSqlBaseName, unquotedSqlBaseNameOfCodec, validateSqlTypeParams };\n\n//# sourceMappingURL=data-type.mjs.map"],"mappings":";;;;;AAKA,MAAM,uBAAuB,WAAW,SAAS;AACjD,MAAM,OAAO;AACb,MAAM,QAAQ,GAAG,KAAK;;;;;;;AAOtB,MAAM,gBAAgB,IAAI,OAAO,OAAO,KAAK,OAAO,MAAM,MAAM,MAAM,eAAe;;AAErF,SAAS,iBAAiB,MAAM;CAC/B,OAAO,cAAc,KAAK,IAAI,IAAI,KAAK,IAAI;AAC5C;AACA,MAAM,eAAe,KAAK,EAAE,KAAK,SAAS,CAAC,CAAC,CAAC,QAAQ,QAAQ,QAAQ;CACpE,MAAM,UAAU,iBAAiB,OAAO,GAAG;CAC3C,OAAO,YAAY,KAAK,KAAK,IAAI,OAAO;EACvC,MAAM,CAAC,KAAK;EACZ,SAAS;CACV,CAAC;AACF,CAAC;;;;;AAKD,SAAS,qBAAqB;CAC7B,MAAM,gBAAgB,kCAAkC,4HAA4H;EACnL,KAAK;EACL,KAAK;CACN,CAAC;AACF;;;;;;;AAOA,MAAM,iBAAiB,YAAY,sBAAsB;CACxD,QAAQ;CACR,mBAAmB;CACnB,SAAS,EAAE,UAAU;CACrB,MAAM;AACP,CAAC"}

package/dist/data-type-DJIvKQHf.d.mts

@@ -0,0 +1,158 @@
+import { i as ReportedSqlType } from "./types-CuCxAQat-Dz8P4xyt.mjs";
+import "./types-ljUNyiWe.mjs";
+import { DataType, DataTypeId, DataTypeLookup, DataTypeSpec, TypeLookups } from "@prisma/orm-framework/components/codec";
+import { Type } from "arktype";
+//#region ../../../2-sql-family/1-core/contract/dist/data-type.d.mts
+//#region src/sql-data-type.d.ts
+/** One way a database type is written or reported. */
+interface SqlTypeText {
+  /** Lower case with single spaces; `{name}` stands for the parameter `name`. */
+  readonly text: string;
+  /** A migration writes this text. */
+  readonly written?: true;
+  /** The database catalog prints this text. */
+  readonly catalog?: true;
+  /** The exact characters written and printed, when they differ from `text` in letter case only. */
+  readonly display?: string;
+}
+type SqlTypeParams = Readonly<Record<string, unknown>>;
+interface SqlDataTypeSpec<Params extends SqlTypeParams = SqlTypeParams> extends Omit<DataTypeSpec, 'normalize'> {
+  readonly params?: Type<Params>;
+  readonly texts?: readonly SqlTypeText[];
+  /** The kind of reported type this data type claims, instead of any text. */
+  readonly claimsKind?: string;
+  /** The id of the type a column of this type is stored as, with the same parameters. A type stored as another declares no texts. */
+  readonly storedAs?: DataTypeId;
+  readonly normalize?: (params: Params) => Params;
+  /** The type's name from its parameters, for a type that claims a kind or whose name is its catalog text. */
+  readonly render?: (params: Params) => string;
+  readonly fromReported?: (reported: ReportedSqlType) => Params;
+  /**
+   * The name `render` writes is the text the database catalog prints, exactly. Such a type has no
+   * texts and claims no kind; it has no base name; verify compares its name with the reported text
+   * unchanged; and a target writes and sends it as given. ADR 273.
+   */
+  readonly nameIsCatalogText?: true;
+}
+interface SqlDataTypeFacts<Params extends SqlTypeParams = SqlTypeParams> {
+  readonly texts: readonly SqlTypeText[];
+  readonly claimsKind: string | undefined;
+  readonly storedAs: DataTypeId | undefined;
+  /** The normal form of `params`; parameters the type's schema refuses are returned as written. */
+  readonly normalize: (params: Params) => Params;
+  readonly render: ((params: Params) => string) | undefined;
+  readonly fromReported: ((reported: ReportedSqlType) => Params) | undefined;
+  readonly nameIsCatalogText: boolean;
+}
+interface SqlDataType<Params extends SqlTypeParams = SqlTypeParams> extends DataType {
+  readonly params?: Type<Params>;
+  readonly sql: SqlDataTypeFacts<Params>;
+}
+/** A data type that claims a type text, with the parameters the text gives in their normal form. */
+interface ResolvedSqlType {
+  readonly dataType: SqlDataType;
+  readonly typeParams: SqlTypeParams;
+}
+/** Declare a SQL data type, refusing a declaration that breaks a rule of the module. */
+declare function sqlDataType<Params extends SqlTypeParams = SqlTypeParams>(id: string, spec: SqlDataTypeSpec<Params>): SqlDataType<Params>;
+/** Whether the name of `type` is the text the database catalog prints, as declared by {@link SqlDataTypeSpec.nameIsCatalogText}. */
+declare function nameIsCatalogText<Params extends SqlTypeParams>(type: SqlDataType<Params>): boolean;
+/** Whether `type` is a data type a SQL column can have. `sql/expression` is the one data type no column has. */
+declare function isSqlDataType(type: DataType): type is SqlDataType;
+/** The parameters, when `type` accepts them; otherwise `CONTRACT.TYPE_PARAMS_INVALID` naming each parameter it refuses. */
+declare function validateSqlTypeParams<Params extends SqlTypeParams>(type: SqlDataType<Params>, params: SqlTypeParams): Params;
+/**
+ * The name of `type` with no parameters, for places where parameters must not appear, such as a
+ * cast. A type whose name is its catalog text has none: its parameters cannot be separated from its
+ * name, so it is refused.
+ */
+declare function sqlBaseName<Params extends SqlTypeParams>(type: SqlDataType<Params>, params: SqlTypeParams): string;
+/**
+ * The base name of `type` with `params`, unquoted, for display. It differs from {@link sqlBaseName}
+ * for a type that claims a kind, where it is the `typeName` parameter as written (`app.status`)
+ * while `sqlBaseName` gives the quoted name `render` writes into SQL (`"app"."status"`), and for a
+ * type whose name is its catalog text, where it is that whole text.
+ */
+declare function unquotedSqlBaseName<Params extends SqlTypeParams>(type: SqlDataType<Params>, params: SqlTypeParams): string;
+/** The SQL data type the codec `codecId` represents. */
+declare function sqlDataTypeOfCodec(codecId: string, lookups: TypeLookups): SqlDataType;
+/**
+ * The length of a column of data type `type` with `typeParams`, in the type's normal form, as verify compares it: a bare Postgres `character` holds 1. `undefined` when the column has no length, or when its data type drops the length because the database does not limit it, as SQLite's text types do.
+ */
+declare function sqlColumnLength(type: DataType | undefined, typeParams: Readonly<Record<string, unknown>> | undefined): number | undefined;
+/** The length of a column of `codecId` in its data type's normal form, or `undefined` for a column with no length or one whose database does not limit it. */
+declare function sqlCodecColumnLength(dataTypes: {
+  readonly lookup: Pick<DataTypeLookup, 'get'>;
+  readonly dataTypeOfCodec: (codecId: string) => DataTypeId | undefined;
+}, codecId: string, typeParams: Readonly<Record<string, unknown>> | undefined): number | undefined;
+/** The type a column of `type` is stored as, whose name DDL writes and the database reports: `type` itself unless it names another. */
+declare function sqlStorageType(type: SqlDataType, lookup: Pick<DataTypeLookup, 'get'>): SqlDataType;
+/** The id of the type a column of the data type `dataTypeId` is stored as: {@link sqlStorageType} of it, which refuses a storage type the lookup does not register, or `dataTypeId` itself when the lookup does not know it as a SQL data type. */
+declare function sqlStorageTypeId(dataTypeId: string, lookup: Pick<DataTypeLookup, 'get'>): string;
+/** The parts of a contract column that make its type. */
+interface SqlColumnTypeFields {
+  readonly dataType: string;
+  readonly typeParams?: Readonly<Record<string, unknown>>;
+  readonly many?: unknown;
+}
+/**
+ * Whether two contract columns have the same type: the types their data types are stored as are one type, those types' parameters are equal in normal form, and both or neither are lists. ADR 254.
+ */
+declare function sameSqlColumnType(a: SqlColumnTypeFields, b: SqlColumnTypeFields, lookup: Pick<DataTypeLookup, 'get'>): boolean;
+/** The type a column of the codec `codecId` is stored as: {@link sqlStorageType} of the data type it represents. */
+declare function sqlStorageTypeOfCodec(codecId: string, lookups: TypeLookups): SqlDataType;
+/** {@link unquotedSqlBaseName} of the type a column of the codec `codecId` is stored as. */
+declare function unquotedSqlBaseNameOfCodec(codecId: string, typeParams: SqlTypeParams | undefined, lookups: TypeLookups): string;
+/** The text a migration writes for `type` with the raw `params`. */
+declare function renderSqlTypeName<Params extends SqlTypeParams>(type: SqlDataType<Params>, params: SqlTypeParams): string;
+/** The text the database catalog prints for `type` with `params`, in their normal form. */
+declare function renderSqlCatalogText<Params extends SqlTypeParams>(type: SqlDataType<Params>, params: SqlTypeParams): string;
+/** Two SQL data types that would both recognise one reported type, and what each claims. */
+interface SqlDataTypeCollision {
+  readonly first: SqlDataType;
+  readonly second: SqlDataType;
+  readonly claims: {
+    readonly by: 'text';
+    readonly first: string;
+    readonly second: string;
+  } | {
+    readonly by: 'kind';
+    readonly kind: string;
+  };
+}
+/**
+ * The first two SQL data types in `types` that would both recognise one reported type: a claiming
+ * text of each collides, or both claim the same kind. Two texts collide when either one's pattern
+ * matches the other with each placeholder written as 1.
+ */
+declare function findSqlDataTypeCollision(types: readonly DataType[]): SqlDataTypeCollision | undefined;
+/**
+ * The data type that claims a reported type, with its parameters in normal form, or undefined when
+ * no type in `dataTypes` claims it or its parameters fail the type's schema.
+ */
+declare function resolveReportedSqlType(reported: ReportedSqlType, dataTypes: readonly DataType[]): ResolvedSqlType | undefined;
+/**
+ * Every data type in `dataTypes` that reads `text` as a migration may write it, with its parameters
+ * in normal form: any of a type's texts counts, whether written, printed by the catalog or only
+ * claimed. Empty when no type reads it or its parameters fail the type's schema. A type that claims
+ * a kind has no texts, so it never reads one.
+ */
+declare function resolveWrittenSqlTypes(text: string, dataTypes: readonly DataType[]): readonly ResolvedSqlType[];
+//#endregion
+//#region src/sql-raw.d.ts
+declare const SQL_RAW_DATA_TYPE_ID: DataTypeId;
+type SqlRawTypeParams = {
+  readonly sql: string;
+};
+/** Returns undefined when `text` may be written as a column's type, else the reason. */
+declare function checkRawTypeText(text: string): string | undefined;
+/**
+ * The data type of a column whose type no other data type claims. Its `sql` parameter is the type
+ * exactly as the database catalog prints it, which migrations write and verify compares. It claims
+ * no reported type, so introspection never reads a column as raw. It has no literal values: it
+ * declares no casts, and its reader refuses every value. ADR 273.
+ */
+declare const sqlRawDataType: SqlDataType<SqlRawTypeParams>;
+//#endregion
+export { unquotedSqlBaseNameOfCodec as A, sqlDataType as C, sqlStorageTypeId as D, sqlStorageType as E, sqlStorageTypeOfCodec as O, sqlColumnLength as S, sqlRawDataType as T, resolveReportedSqlType as _, SqlDataTypeCollision as a, sqlBaseName as b, SqlRawTypeParams as c, checkRawTypeText as d, findSqlDataTypeCollision as f, renderSqlTypeName as g, renderSqlCatalogText as h, SqlDataType as i, validateSqlTypeParams as j, unquotedSqlBaseName as k, SqlTypeParams as l, nameIsCatalogText as m, SQL_RAW_DATA_TYPE_ID as n, SqlDataTypeFacts as o, isSqlDataType as p, SqlColumnTypeFields as r, SqlDataTypeSpec as s, ResolvedSqlType as t, SqlTypeText as u, resolveWrittenSqlTypes as v, sqlDataTypeOfCodec as w, sqlCodecColumnLength as x, sameSqlColumnType as y };
+//# sourceMappingURL=data-type-DJIvKQHf.d.mts.map

package/dist/data-type-DJIvKQHf.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-type-DJIvKQHf.d.mts","names":[],"sources":["../../../../2-sql-family/1-core/contract/dist/data-type.d.mts"],"mappings":";;;;;;;UAKU;;WAEC;;WAEA;;WAEA;;WAEA;;KAEN,gBAAgB,SAAS;UACpB,gBAAgB,eAAe,gBAAgB,uBAAuB,KAAK;WAC1E,SAAS,KAAK;WACd,iBAAiB;;WAEjB;;WAEA,WAAW;WACX,aAAa,QAAQ,WAAW;;WAEhC,UAAU,QAAQ;WAClB,gBAAgB,UAAU,oBAAoB;;;;;;WAM9C;;UAED,iBAAiB,eAAe,gBAAgB;WAC/C,gBAAgB;WAChB;WACA,UAAU;;WAEV,YAAY,QAAQ,WAAW;WAC/B,UAAU,QAAQ;WAClB,gBAAgB,UAAU,oBAAoB;WAC9C;;UAED,YAAY,eAAe,gBAAgB,uBAAuB;WACjE,SAAS,KAAK;WACd,KAAK,iBAAiB;;;UAGvB;WACC,UAAU;WACV,YAAY;;;iBAGN,YAAY,eAAe,gBAAgB,eAAe,YAAY,MAAM,gBAAgB,UAAU,YAAY;;iBAElH,kBAAkB,eAAe,eAAe,MAAM,YAAY;;iBAElE,cAAc,MAAM,WAAW,QAAQ;;iBAEvC,sBAAsB,eAAe,eAAe,MAAM,YAAY,SAAS,QAAQ,gBAAgB;;;;;;iBAMvG,YAAY,eAAe,eAAe,MAAM,YAAY,SAAS,QAAQ;;;;;;;iBAO7E,oBAAoB,eAAe,eAAe,MAAM,YAAY,SAAS,QAAQ;;iBAErF,mBAAmB,iBAAiB,SAAS,cAAc;;;;iBAI3D,gBAAgB,MAAM,sBAAsB,YAAY,SAAS;;iBAEjE,qBAAqB;WAC3B,QAAQ,KAAK;WACb,kBAAkB,oBAAoB;GAC9C,iBAAiB,YAAY,SAAS;;iBAExB,eAAe,MAAM,aAAa,QAAQ,KAAK,yBAAyB;;iBAExE,iBAAiB,oBAAoB,QAAQ,KAAK;;UAEzD;WACC;WACA,aAAa,SAAS;WACtB;;;;;iBAKM,kBAAkB,GAAG,qBAAqB,GAAG,qBAAqB,QAAQ,KAAK;;iBAE/E,sBAAsB,iBAAiB,SAAS,cAAc;;iBAE9D,2BAA2B,iBAAiB,YAAY,2BAA2B,SAAS;;iBAE5F,kBAAkB,eAAe,eAAe,MAAM,YAAY,SAAS,QAAQ;;iBAEnF,qBAAqB,eAAe,eAAe,MAAM,YAAY,SAAS,QAAQ;;UAE7F;WACC,OAAO;WACP,QAAQ;WACR;aACE;aACA;aACA;;aAEA;aACA;;;;;;;;iBAQI,yBAAyB,gBAAgB,aAAa;;;;;iBAKtD,uBAAuB,UAAU,iBAAiB,oBAAoB,aAAa;;;;;;;iBAOnF,uBAAuB,cAAc,oBAAoB,sBAAsB;;;cAGlF,sBAAsB;KAC/B;WACM;;;iBAGM,iBAAiB;;;;;;;cAOpB,gBAAgB,YAAY"}

package/dist/data-type-support-BhSoPUFj.mjs

@@ -0,0 +1,9 @@
+//#region ../../../2-sql-family/1-core/contract/dist/data-type-support.mjs
+/** A string as a contract source writes it, with the escapes its string reader resolves. */
+function escapePslString(value) {
+	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+}
+//#endregion
+export { escapePslString as t };
+
+//# sourceMappingURL=data-type-support-BhSoPUFj.mjs.map

package/dist/data-type-support-BhSoPUFj.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-type-support-BhSoPUFj.mjs","names":[],"sources":["../../../../2-sql-family/1-core/contract/dist/data-type-support.mjs"],"sourcesContent":["//#region src/data-type-support.ts\n/** A string as a contract source writes it, with the escapes its string reader resolves. */\nfunction escapePslString(value) {\n\treturn value.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, \"\\\\\\\"\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\");\n}\n//#endregion\nexport { escapePslString };\n\n//# sourceMappingURL=data-type-support.mjs.map"],"mappings":";;AAEA,SAAS,gBAAgB,OAAO;CAC/B,OAAO,MAAM,QAAQ,OAAO,MAAM,CAAC,CAAC,QAAQ,MAAM,MAAM,CAAC,CAAC,QAAQ,OAAO,KAAK,CAAC,CAAC,QAAQ,OAAO,KAAK;AACrG"}

package/dist/data-type-support-CXpA0ex-.d.mts

@@ -0,0 +1,7 @@
+//#region ../../../2-sql-family/1-core/contract/dist/data-type-support.d.mts
+//#region src/data-type-support.d.ts
+/** A string as a contract source writes it, with the escapes its string reader resolves. */
+declare function escapePslString(value: string): string;
+//#endregion
+export { escapePslString as t };
+//# sourceMappingURL=data-type-support-CXpA0ex-.d.mts.map

package/dist/data-type-support-CXpA0ex-.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-type-support-CXpA0ex-.d.mts","names":[],"sources":["../../../../2-sql-family/1-core/contract/dist/data-type-support.d.mts"],"mappings":";;;iBAEiB,gBAAgB"}