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

package/dist/lane-query-builder.d.mts

@@ -1,236 +0,0 @@
-import { r as StorageTable } from "./storage-table-DSeWszOL-CI-cItEK.mjs";
-import { c as SqlStorage } from "./sql-storage-8LqxeLAY-DH4DdUXx.mjs";
-import { h as ExtractStorageColumnTypes } from "./types-BDUG29Df-LE85dIXP.mjs";
-import { n as StorageColumnTypeAcrossNamespaces } from "./types-UcHa2cTe.mjs";
-import { Brand, Contract, StorageHashBase } from "@prisma/orm-framework/contract/types";
-import "@standard-schema/spec";
-//#region ../../../2-sql/4-lanes/query-builder/dist/index.d.mts
-//#region src/type-errors.d.ts
-/**
- * An error message type, prefixed with `[error]`.
- *
- * @template TMessage The error message.
- */
-type ErrorMessage = `[error] ${string}`;
-/**
- * An error type indicating that the previous function call had bad input.
- * To be used as a return type.
- *
- * @template TMessage The error message.
- */
-type PreviousFunctionReceivedBadInputError<TMessage extends ErrorMessage> = Brand<TMessage>;
-//#endregion
-//#region src/column-reference.d.ts
-/**
- * An object representing a reference to a column in a table in the database.
- *
- * @template TColumnName The name of the column.
- * @template TTableName The name of the table this column belongs to.
- * @template THash The contract storage hash belonging to the database this column is in.
- */
-type ColumnReference<TColumnName extends string = string, TTableName extends string = string, THash extends StorageHashBase<string> = StorageHashBase<string>> = {
-  readonly '~name': TColumnName;
-  readonly '~table': TTableName;
-} & Brand<'[info] this column reference belongs to the following table reference:', `${TTableName}@${THash}`>;
-/**
- * An error type indicating that the provided column reference is out of the contract's scope.
- * To be used in reference creators, e.g. `createRef()`.
- *
- * @template TMessage The error message.
- */
-type ColumnReferenceOutOfContractError<TMessage extends ErrorMessage> = Brand<TMessage>;
-/**
- * A type representing a reference to all columns in the current query context.
- */
-type Asterisk = {
-  readonly '~name': '*';
-  readonly '~table': null;
-} & Brand<'[info] referencing all columns in the current query context'>;
-/**
- * A type representing a reference to all columns in a specific table.
- *
- * @template TTableName The name of the table whose columns are being referenced.
- * @template THash The contract storage hash belonging to the database this column is in.
- */
-type TableAsterisk<TTableName extends string = string, THash extends StorageHashBase<string> = StorageHashBase<string>> = {
-  readonly '~name': '*';
-  readonly '~table': TTableName;
-} & Brand<'[info] referencing all columns that belong to the following table reference:', `${TTableName}@${THash}`>;
-//#endregion
-//#region ../sql-builder/dist/db-D18PrXKW.d.mts
-//#endregion
-//#region src/types/db.d.ts
-type CapabilitiesBase = Record<string, Record<string, boolean>>;
-type NamespaceEntries = Readonly<Record<string, Readonly<Record<string, unknown>>>>;
-type NamespaceDomain = Readonly<Record<string, {
-  readonly models: Readonly<Record<string, unknown>>;
-}>>;
-type TableProxyContract = {
-  readonly domain: {
-    readonly namespaces: NamespaceDomain;
-  };
-  readonly storage: {
-    readonly namespaces: Readonly<Record<string, {
-      readonly entries: NamespaceEntries;
-    }>>;
-  };
-  readonly capabilities: CapabilitiesBase;
-};
-type TablesInNamespace<NS extends {
-  readonly entries: NamespaceEntries;
-}> = NS['entries']['table'] extends Readonly<Record<string, StorageTable>> ? NS['entries']['table'] : Readonly<Record<string, StorageTable>>;
-type UnboundTables$1<C extends TableProxyContract> = { readonly [Name in TableNamesAcrossNamespaces<C>]: TableInAnyNamespace<C, Name>; };
-type TableNamesAcrossNamespaces<C extends TableProxyContract> = { [NSId in keyof C['storage']['namespaces']]: keyof TablesInNamespace<C['storage']['namespaces'][NSId]> & string; }[keyof C['storage']['namespaces']];
-type TableInAnyNamespace<C extends TableProxyContract, Name extends string> = { [NSId in keyof C['storage']['namespaces']]: Name extends keyof TablesInNamespace<C['storage']['namespaces'][NSId]> ? TablesInNamespace<C['storage']['namespaces'][NSId]>[Name] : never; }[keyof C['storage']['namespaces']];
-//#endregion
-//#region src/type-atoms.d.ts
-/**
- * A utility type to drain outer generics from a type. A compiler micro-optimization.
- *
- * @template TThing The type to drain.
- */
-type DrainOuterGeneric<TThing> = [TThing] extends [unknown] ? TThing : never;
-/**
- * A utility type to ensure that exactly one property of an object type is present.
- *
- * @template TObject The object type to check.
- */
-type ExactlyOneProperty<TObject extends object> = { [K in keyof TObject]-?: IsNever<Exclude<keyof TObject, K>>; }[keyof TObject];
-/**
- * A utility type to merge two objects.
- *
- * @template TObject0 The first object.
- * @template TObject1 The second object.
- */
-type MergeObjects<TObject0 extends object, TObject1 extends object> = DrainOuterGeneric<IsNever<TObject0> extends true ? TObject1 : { readonly [K in keyof TObject0 | keyof TObject1]: K extends keyof TObject1 ? TObject1[K] : K extends keyof TObject0 ? TObject0[K] : never; }>;
-/**
- * A utility type to determine if a type is `never`.
- *
- * @template TThing The type to check.
- */
-type IsNever<TThing> = [TThing] extends [never] ? true : false;
-/**
- * A utility type to simplify an object type for better readability.
- *
- * @template TObject The object type to simplify.
- */
-type Simplify<TObject extends object> = DrainOuterGeneric<{ [K in keyof TObject]: TObject[K]; } & {}>;
-//#endregion
-//#region src/selection.d.ts
-type UnboundTables<TContract extends Contract<SqlStorage>> = UnboundTables$1<TContract & TableProxyContract>;
-type ExtractOutputType<TContract extends Contract<SqlStorage>, TTableName extends keyof UnboundTables<TContract> & string, TColumnName extends keyof UnboundTables<TContract>[TTableName]['columns'] & string> = StorageColumnTypeAcrossNamespaces<ExtractStorageColumnTypes<TContract>, TTableName, TColumnName>;
-/**
- * A type representing a selection of columns in a SQL `select` query in the
- * most generic form.
- */
-type Selection = Record<string, SelectionValue<unknown, unknown>>;
-/**
- * A type representing the value of a selected column in a SQL `select` query.
- *
- * @template TOutput The output type of the selected column.
- * @template TDatatype The database-side datatype of the selected column.
- */
-interface SelectionValue<TOutput, TDatatype extends string | unknown = unknown> {
-  readonly '~datatype': TDatatype;
-  readonly '~output': TOutput;
-}
-/**
- * A utility type to convert a table's columns into a {@link Selection}.
- *
- * @template TContract The contract that describes the database.
- * @template TTableName The name of the table whose columns will be included in the selection.
- */
-type TableToSelection<TContract extends Contract<SqlStorage>, TTableName extends keyof UnboundTables<TContract> & string> = DrainOuterGeneric<{ readonly [ColumnName in keyof UnboundTables<TContract>[TTableName]['columns'] & string]: SelectionValue<ExtractOutputType<TContract, TTableName, ColumnName>, UnboundTables<TContract>[TTableName]['columns'][ColumnName]['nativeType']>; }>;
-//#endregion
-//#region src/table-reference.d.ts
-/**
- * An object representing a reference to a table in the database.
- *
- * @template TName The name of the table. `string` is all tables, a union of string literals is a set of specific tables, a single string literal is a specific table.
- * @template THash The contract storage hash belonging to the database this table is in.
- */
-type TableReference<TName extends string = string, THash extends StorageHashBase<string> = StorageHashBase<string>> = {
-  readonly '~name': TName;
-} & Brand<'[info] this table reference belongs to the contract with the following storage hash:', THash>;
-/**
- * An error type indicating that the provided table reference is out of the contract's scope.
- * To be used in reference creators, e.g. `createRef()`.
- *
- * @template TMessage The error message.
- */
-type TableReferenceOutOfContractError<TMessage extends ErrorMessage> = Brand<TMessage>;
-/**
- * An error type indicating that the provided table reference is too wide.
- * To be used as a `never` alternative in conditional types.
- *
- * @template TMessage The error message.
- */
-type TableReferenceTooWideError<TMessage extends ErrorMessage> = Brand<TMessage>;
-//#endregion
-//#region src/ref.d.ts
-/**
- * A fluent API representing references to tables and columns in a SQL contract.
- *
- * @template TContract The contract that describes the database.
- */
-type Ref<TContract extends Contract<SqlStorage>> = { readonly [TableName in keyof UnboundTables<TContract> & string]: TableReference<TableName, TContract['storage']['storageHash']> & { readonly [ColumnName in Exclude<keyof UnboundTables<TContract>[TableName]['columns'], keyof TableReference> & string]: ColumnReference<ColumnName, TableName, TContract['storage']['storageHash']>; } & {
-  readonly ['*']: TableAsterisk<TableName, TContract['storage']['storageHash']>;
-} & Record<PropertyKey, ColumnReferenceOutOfContractError<`[error] reference to a non-existing column in the '${TableName}' table`>>; } & {
-  readonly ['*']: Asterisk;
-} & Record<PropertyKey, TableReferenceOutOfContractError<`[error] reference to a non-existing table in the contract`>>;
-/**
- * Creates a reference object for the given SQL contract.
- *
- * @template TContract The contract that describes the database.
- */
-declare function createRef<TContract extends Contract<SqlStorage>>(_contract: TContract): Ref<TContract>;
-//#endregion
-//#region src/select-builder.d.ts
-/**
- * A builder for SQL `select` queries.
- *
- * @template TContract The contract that describes the database.
- * @template TTables The tables involved in the current `select` query.
- * @template TSelection The current selection of the `select` query.
- */
-declare class SelectBuilder<TContract extends Contract<SqlStorage>, TTables extends UnboundTables<Contract<SqlStorage>>, TSelection extends Selection = never> {
-  #private;
-  constructor(contract: TContract);
-  select(asterisk: Asterisk): ExactlyOneProperty<TTables> extends true ? SelectBuilder<TContract, TTables, MergeObjects<TSelection, TableToSelection<TContract, keyof TTables & string>>> : PreviousFunctionReceivedBadInputError<'[error] selecting all columns via `*` results in ambiguity when multiple tables are involved in the query'>;
-  select<TTableName extends keyof TTables & string>(asterisk: TableAsterisk<TTableName, TContract['storage']['storageHash']>): SelectBuilder<TContract, TTables, MergeObjects<TSelection, TableToSelection<TContract, TTableName>>>;
-  select(arg: never): PreviousFunctionReceivedBadInputError<'[error] invalid input in previous `select()` call'>;
-  build(): IsNever<TSelection> extends true ? never : Simplify<TSelection>;
-}
-//#endregion
-//#region src/root.d.ts
-/**
- * The root of all builder.
- *
- * @template TContract The contract that describes the database.
- */
-declare class Root<TContract extends Contract<SqlStorage>> {
-  #private;
-  constructor(contract: TContract);
-  /**
-   * SQL's `from` clause, where all `select` queries actually start from.
-   *
-   * @param table The table to select from.
-   */
-  from(table: TableReference<never>): PreviousFunctionReceivedBadInputError<'[error] invalid table reference in previous `root.from()` call will probably cause runtime errors'>;
-  /**
-   * @template TName The name of the table to select from.
-   */
-  from<TName extends string>(table: string extends TName ? TableReferenceTooWideError<'[error] `root.from()` call received a table reference without a specific table name'> : TableReference<TName, TContract['storage']['storageHash']>): TName extends string ? SelectBuilder<TContract, Pick<UnboundTables<TContract>, TName>> : PreviousFunctionReceivedBadInputError<'[error] invalid table reference in previous `root.from()` call will probably cause runtime errors'>;
-  from(table: TableReferenceTooWideError<'[error] `root.from()` call received a table reference without a specific table name'>): PreviousFunctionReceivedBadInputError<'[error] invalid table reference in previous `root.from()` call will probably cause runtime errors'>;
-}
-/**
- * Creates a new `Root` instance.
- */
-declare function createRoot(contract: never): PreviousFunctionReceivedBadInputError<'[error] root creation will likely fail at runtime given the passed contract is not valid or verified'>;
-/**
- * @template TContract The contract that describes the database.
- */
-declare function createRoot<TContract extends Contract<SqlStorage>>(contract: TContract): Root<TContract>;
-//#endregion
-export { type Asterisk, type ColumnReference, type ColumnReferenceOutOfContractError, type DrainOuterGeneric, type ErrorMessage, type ExactlyOneProperty, type ExtractOutputType, type IsNever, type MergeObjects, type PreviousFunctionReceivedBadInputError, type Ref, type Root, type SelectBuilder, type Selection, type SelectionValue, type Simplify, type TableAsterisk, type TableReference, type TableReferenceOutOfContractError, type TableReferenceTooWideError, type TableToSelection, createRef, createRoot };
-//# sourceMappingURL=lane-query-builder.d.mts.map

package/dist/lane-query-builder.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"lane-query-builder.d.mts","names":[],"sources":["../../../../2-sql/4-lanes/query-builder/dist/index.d.mts"],"mappings":"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"}

package/dist/lane-query-builder.mjs

@@ -1,67 +0,0 @@
-//#region ../../../2-sql/4-lanes/query-builder/dist/index.mjs
-/**
-* Creates a reference object for the given SQL contract.
-*
-* @template TContract The contract that describes the database.
-*/
-function createRef(_contract) {
-	return new Proxy({}, { get(_target, tableName) {
-		if (tableName === "*") return Object.freeze({
-			"~name": tableName,
-			"~table": null
-		});
-		return new Proxy({}, { get(_target, columnName) {
-			if (columnName === "~name") return tableName;
-			return Object.freeze({
-				"~name": columnName,
-				"~table": tableName
-			});
-		} });
-	} });
-}
-/**
-* A builder for SQL `select` queries.
-*
-* @template TContract The contract that describes the database.
-* @template TTables The tables involved in the current `select` query.
-* @template TSelection The current selection of the `select` query.
-*/
-var SelectBuilder = class {
-	#contract;
-	constructor(contract) {
-		this.#contract = contract;
-	}
-	select(..._args) {
-		return this;
-	}
-	build() {
-		return {};
-	}
-};
-/**
-* The root of all builder.
-*
-* @template TContract The contract that describes the database.
-*/
-var Root = class {
-	#contract;
-	constructor(contract) {
-		this.#contract = contract;
-	}
-	/**
-	* @internal
-	*/
-	from(_table) {
-		return new SelectBuilder(this.#contract);
-	}
-};
-/**
-* @internal
-*/
-function createRoot(contract) {
-	return new Root(contract);
-}
-//#endregion
-export { createRef, createRoot };
-
-//# sourceMappingURL=lane-query-builder.mjs.map

package/dist/lane-query-builder.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"lane-query-builder.mjs","names":["#contract"],"sources":["../../../../2-sql/4-lanes/query-builder/dist/index.mjs"],"sourcesContent":["//#region src/ref.ts\n/**\n* Creates a reference object for the given SQL contract.\n*\n* @template TContract The contract that describes the database.\n*/\nfunction createRef(_contract) {\n\treturn new Proxy({}, { get(_target, tableName) {\n\t\tif (tableName === \"*\") return Object.freeze({\n\t\t\t\"~name\": tableName,\n\t\t\t\"~table\": null\n\t\t});\n\t\treturn new Proxy({}, { get(_target, columnName) {\n\t\t\tif (columnName === \"~name\") return tableName;\n\t\t\treturn Object.freeze({\n\t\t\t\t\"~name\": columnName,\n\t\t\t\t\"~table\": tableName\n\t\t\t});\n\t\t} });\n\t} });\n}\n//#endregion\n//#region src/select-builder.ts\n/**\n* A builder for SQL `select` queries.\n*\n* @template TContract The contract that describes the database.\n* @template TTables The tables involved in the current `select` query.\n* @template TSelection The current selection of the `select` query.\n*/\nvar SelectBuilder = class {\n\t#contract;\n\tconstructor(contract) {\n\t\tthis.#contract = contract;\n\t}\n\tselect(..._args) {\n\t\treturn this;\n\t}\n\tbuild() {\n\t\treturn {};\n\t}\n};\n//#endregion\n//#region src/root.ts\n/**\n* The root of all builder.\n*\n* @template TContract The contract that describes the database.\n*/\nvar Root = class {\n\t#contract;\n\tconstructor(contract) {\n\t\tthis.#contract = contract;\n\t}\n\t/**\n\t* @internal\n\t*/\n\tfrom(_table) {\n\t\treturn new SelectBuilder(this.#contract);\n\t}\n};\n/**\n* @internal\n*/\nfunction createRoot(contract) {\n\treturn new Root(contract);\n}\n//#endregion\nexport { createRef, createRoot };\n\n//# sourceMappingURL=index.mjs.map"],"mappings":";;;;;;AAMA,SAAS,UAAU,WAAW;CAC7B,OAAO,IAAI,MAAM,CAAC,GAAG,EAAE,IAAI,SAAS,WAAW;EAC9C,IAAI,cAAc,KAAK,OAAO,OAAO,OAAO;GAC3C,SAAS;GACT,UAAU;EACX,CAAC;EACD,OAAO,IAAI,MAAM,CAAC,GAAG,EAAE,IAAI,SAAS,YAAY;GAC/C,IAAI,eAAe,SAAS,OAAO;GACnC,OAAO,OAAO,OAAO;IACpB,SAAS;IACT,UAAU;GACX,CAAC;EACF,EAAE,CAAC;CACJ,EAAE,CAAC;AACJ;;;;;;;;AAUA,IAAI,gBAAgB,MAAM;CACzB;CACA,YAAY,UAAU;EACrB,KAAKA,YAAY;CAClB;CACA,OAAO,GAAG,OAAO;EAChB,OAAO;CACR;CACA,QAAQ;EACP,OAAO,CAAC;CACT;AACD;;;;;;AAQA,IAAI,OAAO,MAAM;CAChB;CACA,YAAY,UAAU;EACrB,KAAKA,YAAY;CAClB;;;;CAIA,KAAK,QAAQ;EACZ,OAAO,IAAI,cAAc,KAAKA,SAAS;CACxC;AACD;;;;AAIA,SAAS,WAAW,UAAU;CAC7B,OAAO,IAAI,KAAK,QAAQ;AACzB"}

package/dist/middleware--TtoxUiW.d.mts

@@ -1 +0,0 @@
-import "./middleware-AhTz1BOW-th-Suxuf.mjs";

package/dist/middleware-AhTz1BOW-th-Suxuf.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"middleware-AhTz1BOW-th-Suxuf.d.mts","names":[],"sources":["../../../../2-sql/4-lanes/relational-core/dist/middleware-AhTz1BOW.d.mts"],"mappings":";;;;;;;;;;;;;;cAac;;;;;;;;;;UAUJ,eAAe;YACb,sBAAsB;;;;;;;UAOxB,cAAc;WACb,KAAK,eAAe;WACpB;WACA,SAAS;;;;;;;;;;KAUf,mBAAmB,kBAAkB,8BAA8B,WAAW,qBAAqB,cAAc,YAAY,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;UAyB9I,mBAAmB,kBAAkB,0BAA0B,iCAAiC;;EAExG,WAAW,iBAAiB,mBAAmB;;;;;;;EAO/C,aAAa,uBAAuB,oBAAoB,KAAK,eAAe,WAAW,UAAU,UAAU;EAC3G,aAAa,KAAK,2BAA2B;;EAE7C,cAAc,SAAS;aACZ,KAAK,sBAAsB;aAC3B;;;;;;;;;;;;;UAaH,2BAA2B,kBAAkB,0BAA0B,iCAAiC,mBAAmB;EACnI;;;;;;;;;;;;;;;;;iBAiBe,yBAAyB,kBAAkB,0BAA0B,yBAAyB,MAAM,mBAAmB,2BAA2B"}

package/dist/middleware-CMr4CHNz-DHIUdxlm.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"middleware-CMr4CHNz-DHIUdxlm.mjs","names":[],"sources":["../../../../2-sql/4-lanes/relational-core/dist/middleware-CMr4CHNz.mjs"],"sourcesContent":["import { t as collectOrderedParamRefs } from \"./util-DQQgv2j1.mjs\";\n//#region src/middleware/param-ref-mutator.ts\n/**\n* Build a {@link SqlParamRefMutatorInternal} for the given lowered plan.\n*\n* The mutator captures `plan.params` by reference and walks\n* `plan.ast` (via `collectOrderedParamRefs`) on demand to build\n* entries. Mutations write to a lazily-allocated working copy so the\n* fast path (no mutation) preserves bit-for-bit reference identity to\n* the original `plan.params`.\n*\n* Threading: `plan.ast` carries the canonical `ParamRef` ordering used\n* by every consumer (renderer's `$N` index map, encode-side metadata\n* walk, etc.). The mutator's `entries()` yields the same order so\n* middleware that filters by codec id sees ParamRefs in the order the\n* runtime will encode them.\n*/\nfunction createSqlParamRefMutator(plan) {\n\tconst originalParams = plan.params;\n\tconst refs = plan.ast ? collectOrderedParamRefs(plan.ast) : [];\n\tlet workingParams;\n\tconst indexOfRef = (handle) => {\n\t\treturn refs.indexOf(handle);\n\t};\n\tconst ensureWorkingParams = () => {\n\t\tif (!workingParams) workingParams = [...originalParams];\n\t\treturn workingParams;\n\t};\n\tconst writeAt = (index, value) => {\n\t\tconst buffer = ensureWorkingParams();\n\t\tbuffer[index] = value;\n\t};\n\tfunction* entries() {\n\t\tconst view = workingParams ?? originalParams;\n\t\tfor (let i = 0; i < refs.length; i++) {\n\t\t\tconst ref = refs[i];\n\t\t\tif (!ref) continue;\n\t\t\tconst handle = ref;\n\t\t\tlet value;\n\t\t\tlet codecId;\n\t\t\tif (ref.kind === \"param-ref\") {\n\t\t\t\tvalue = i < view.length ? view[i] : ref.value;\n\t\t\t\tcodecId = ref.codec?.codecId;\n\t\t\t} else {\n\t\t\t\tvalue = i < view.length ? view[i] : void 0;\n\t\t\t\tcodecId = ref.codec.codecId;\n\t\t\t}\n\t\t\tyield {\n\t\t\t\tref: handle,\n\t\t\t\tvalue,\n\t\t\t\tcodecId\n\t\t\t};\n\t\t}\n\t}\n\tfunction replaceValue(handle, newValue) {\n\t\tconst index = indexOfRef(handle);\n\t\tif (index < 0) return;\n\t\twriteAt(index, newValue);\n\t}\n\tfunction replaceValues(updates) {\n\t\tfor (const { ref, newValue } of updates) {\n\t\t\tconst index = indexOfRef(ref);\n\t\t\tif (index < 0) continue;\n\t\t\twriteAt(index, newValue);\n\t\t}\n\t}\n\treturn {\n\t\tentries,\n\t\treplaceValue,\n\t\treplaceValues,\n\t\tcurrentParams() {\n\t\t\tif (!workingParams) return originalParams;\n\t\t\treturn Object.freeze([...workingParams]);\n\t\t}\n\t};\n}\n//#endregion\nexport { createSqlParamRefMutator as t };\n\n//# sourceMappingURL=middleware-CMr4CHNz.mjs.map"],"mappings":";;;;;;;;;;;;;;;;;AAiBA,SAAS,yBAAyB,MAAM;CACvC,MAAM,iBAAiB,KAAK;CAC5B,MAAM,OAAO,KAAK,MAAM,wBAAwB,KAAK,GAAG,IAAI,CAAC;CAC7D,IAAI;CACJ,MAAM,cAAc,WAAW;EAC9B,OAAO,KAAK,QAAQ,MAAM;CAC3B;CACA,MAAM,4BAA4B;EACjC,IAAI,CAAC,eAAe,gBAAgB,CAAC,GAAG,cAAc;EACtD,OAAO;CACR;CACA,MAAM,WAAW,OAAO,UAAU;EACjC,MAAM,SAAS,oBAAoB;EACnC,OAAO,SAAS;CACjB;CACA,UAAU,UAAU;EACnB,MAAM,OAAO,iBAAiB;EAC9B,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;GACrC,MAAM,MAAM,KAAK;GACjB,IAAI,CAAC,KAAK;GACV,MAAM,SAAS;GACf,IAAI;GACJ,IAAI;GACJ,IAAI,IAAI,SAAS,aAAa;IAC7B,QAAQ,IAAI,KAAK,SAAS,KAAK,KAAK,IAAI;IACxC,UAAU,IAAI,OAAO;GACtB,OAAO;IACN,QAAQ,IAAI,KAAK,SAAS,KAAK,KAAK,KAAK;IACzC,UAAU,IAAI,MAAM;GACrB;GACA,MAAM;IACL,KAAK;IACL;IACA;GACD;EACD;CACD;CACA,SAAS,aAAa,QAAQ,UAAU;EACvC,MAAM,QAAQ,WAAW,MAAM;EAC/B,IAAI,QAAQ,GAAG;EACf,QAAQ,OAAO,QAAQ;CACxB;CACA,SAAS,cAAc,SAAS;EAC/B,KAAK,MAAM,EAAE,KAAK,cAAc,SAAS;GACxC,MAAM,QAAQ,WAAW,GAAG;GAC5B,IAAI,QAAQ,GAAG;GACf,QAAQ,OAAO,QAAQ;EACxB;CACD;CACA,OAAO;EACN;EACA;EACA;EACA,gBAAgB;GACf,IAAI,CAAC,eAAe,OAAO;GAC3B,OAAO,OAAO,OAAO,CAAC,GAAG,aAAa,CAAC;EACxC;CACD;AACD"}

package/dist/migration-CK4oePIo.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"migration-CK4oePIo.mjs","names":[],"sources":["../../../../2-sql/9-family/dist/migration.mjs"],"sourcesContent":["import { deriveProvidedInvariants } from \"@internal/migration-tools/invariants\";\nimport { Migration } from \"@internal/migration-tools/migration\";\nimport { isThenable } from \"@internal/utils/promise\";\n//#region src/core/sql-migration.ts\n/**\n* Family-owned base class for SQL migrations.\n*\n* Generic in `TDetails` (family plan target details, e.g. Postgres vs SQLite)\n* and in `TTargetId` (the literal target identifier, e.g. `'postgres'`).\n*\n* Adapters (Postgres, SQLite, …) extend this with a concrete `TDetails` and\n* a fixed `TTargetId` literal, so the public `Migration<TOp>` base sees the\n* fully concrete operation shape. Target-free code in SQL family / tooling\n* parameterises over `TDetails` (and usually `TTargetId = string`).\n*\n* The `Start` / `End` contract generics are forwarded to the framework\n* `Migration` base so the derived `describe()` and the per-target view getters\n* (`PostgresMigration` / `SqliteMigration`) carry each migration's precise\n* contract types. The view getters themselves live on the per-target bases\n* because the SQL ContractView shapes differ per target (SQLite unwraps its\n* sole namespace to the root; Postgres is schema-qualified).\n*\n* Keeps target-free contract/runtime features in the family layer while\n* letting adapters own target shape.\n*/\nvar SqlMigration = class extends Migration {\n\t/**\n\t* Sorted, deduplicated invariant ids declared by this migration's\n\t* data-transform ops. Derived from `this.operations` so the field remains\n\t* consistent with the operation list — planner-built plans (`db init`,\n\t* `db update`) yield `[]` because they emit no data-transform ops.\n\t*\n\t* Required by `SqlMigrationPlan.providedInvariants` (tightened from\n\t* optional at the SQL-family layer); the framework-level\n\t* `MigrationPlan.providedInvariants?` stays optional.\n\t*/\n\tget providedInvariants() {\n\t\treturn deriveProvidedInvariants(this.operations.filter((op) => !isThenable(op)));\n\t}\n};\n//#endregion\nexport { SqlMigration as Migration };\n\n//# sourceMappingURL=migration.mjs.map"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,IAAI,eAAe,cAAc,UAAU;;;;;;;;;;;CAW1C,IAAI,qBAAqB;EACxB,OAAO,yBAAyB,KAAK,WAAW,QAAQ,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;CAChF;AACD"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"migration-CjDRZNep.d.mts","names":[],"sources":["../../../../2-sql/9-family/dist/migration.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA0BuB,aAAa,iBAAiB,sBAAsB,mCAAmC,cAAc,SAAS,cAAc,SAAS,aAAa,YAAY,SAAS,cAAc,SAAS,qBAAqB,UAAU,0BAA0B,kBAAkB,WAAW,OAAO;;;;;;;;;;;MAW5S"}

package/dist/naming-CV9j2pXl-KARaDReS.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"naming-CV9j2pXl-KARaDReS.d.mts","names":[],"sources":["../../../../2-sql/1-core/schema-ir/dist/naming-CV9j2pXl.d.mts"],"mappings":";;iBACiB,iBAAiB,mBAAmB;UAC3C;;WAEC;;WAEA;;;;;;;;;;;KAWN;WACM;WACA;;WAEA;IACP;;iBAEa,OAAO,QAAQ;;;;;;;;iBAQf,SAAS,cAAc,6BAA6B;;;;;;iBAMpD,YAAY,cAAc,6BAA6B;;;;;;;;;;;;;;iBAcvD,iBAAiB,eAAe;;;;;;;iBAOhC,eAAe,gBAAgB;;;;;;;;iBAQ/B,cAAc,eAAe;;;;;;;;;;;;;;;;iBAgB7B,iBAAiB;;;;;;;;;;;;;;;iBAejB,wBAAwB;;;;;;KAMpC;;;;;;;;iBAQY,uBAAuB,mBAAmB,oBAAoB,MAAM;;;;;;;;;;;;;iBAapE,qBAAqB,mBAAmB,aAAa,mBAAmB;UAC/E;WACC;WACA;WACA;WACA;WACA;WACA,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2BJ,0BAA0B;iBAC1B,wBAAwB,OAAO;;;;;;;;;cASlC;;;;;iBAKG,2BAA2B,gBAAgB;;;;;;;iBAO3C,8BAA8B"}

package/dist/naming-DKr4TJd7-Cszhq9RV.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"naming-DKr4TJd7-Cszhq9RV.mjs","names":[],"sources":["../../../../2-sql/1-core/schema-ir/dist/naming-DKr4TJd7.mjs"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport { ContractValidationError } from \"@internal/contract/contract-validation-error\";\nimport { structuredError } from \"@internal/utils/structured-error\";\n//#region src/naming.ts\nfunction defaultIndexName(tableName, columns) {\n\treturn `${tableName}_${columns.join(\"_\")}_idx`;\n}\n/** The flat name the union describes. Inverse of {@link namingOf}. */\nfunction nameOf(naming) {\n\treturn naming.kind === \"wire\" ? formatWireName(naming.prefix, naming.hash) : naming.name;\n}\n/**\n* The naming a name-identified node was built with, read back off the flat\n* pair it stores. Inverse of {@link nameOf}, and total for that\n* reason: the constructor derived `name` from the union, so the two agree.\n* Flat data arriving from outside the process goes through\n* {@link parseNaming} instead.\n*/\nfunction namingOf(name, prefix) {\n\tif (prefix === void 0) return {\n\t\tkind: \"exact\",\n\t\tname\n\t};\n\treturn {\n\t\tkind: \"wire\",\n\t\tprefix,\n\t\thash: name.slice(prefix.length + 1)\n\t};\n}\n/**\n* Reads naming out of flat stored data — deserialized contract JSON and the\n* literals a user may hand-edit, the one place a name and a prefix can still\n* disagree. Throws when a declared prefix does not parse back out of the name.\n*/\nfunction parseNaming(name, prefix) {\n\tif (prefix === void 0) return {\n\t\tkind: \"exact\",\n\t\tname\n\t};\n\tconst parsed = parseWireName(name);\n\tif (parsed === void 0 || parsed.prefix !== prefix) throw new ContractValidationError(`\"${name}\": prefix \"${prefix}\" does not match the wire name (expected \"${formatWireName(prefix, \"<8hex>\")}\").`, \"storage\");\n\treturn {\n\t\tkind: \"wire\",\n\t\tprefix: parsed.prefix,\n\t\thash: parsed.hash\n\t};\n}\n/**\n* The naming an object read out of a live catalog has: a wire-shaped name\n* gets the wire arm so the rename pass can pair it by prefix, and every\n* other name is exact.\n*\n* The wire answer is a claim about the name's SHAPE only — the hash is\n* deliberately not recomputed from the object's content here. Nothing\n* downstream reads it as more than that: the differ always asks the\n* contract-derived side to choose the comparison, so a shape-only wire\n* claim on the introspected side never suppresses a body comparison, and\n* `contract infer` recomputes the hash independently before it will emit an\n* index as wire-named.\n*/\nfunction namingOfLiveName(name) {\n\tconst wire = parseWireName(name);\n\treturn wire === void 0 ? {\n\t\tkind: \"exact\",\n\t\tname\n\t} : {\n\t\tkind: \"wire\",\n\t\tprefix: wire.prefix,\n\t\thash: wire.hash\n\t};\n}\nconst WIRE_NAME_PATTERN = /^(.+)_([0-9a-f]{8})$/;\n/**\n* Assembles a wire name from its user-supplied prefix and its 8-hex\n* content-hash suffix. This module owns the `<prefix>_<hash>` format on both\n* sides — construction here and parsing in {@link parseWireName} — so the two\n* never drift.\n*/\nfunction formatWireName(prefix, hash) {\n\treturn `${prefix}_${hash}`;\n}\n/**\n* Splits a wire name (`<prefix>_<8hex>`) into its prefix and content-hash\n* suffix. Returns `undefined` when the name does not follow the wire-name\n* shape (e.g. an object created outside the toolchain) — callers treat such\n* names as all-prefix. Consumed by introspection (prefix extraction) and by\n* rename pairing (same hash, different prefix).\n*/\nfunction parseWireName(name) {\n\tconst match = WIRE_NAME_PATTERN.exec(name);\n\tconst prefix = match?.[1];\n\tconst hash = match?.[2];\n\tif (prefix === void 0 || hash === void 0) return void 0;\n\treturn {\n\t\tprefix,\n\t\thash\n\t};\n}\n/**\n* Stabilizes an authored SQL body (index expression, partial-index predicate,\n* RLS policy predicate) for hashing: trim, and collapse runs of internal\n* whitespace to a single space.\n*\n* This is deliberately minimal. The content hash is the equivalence relation\n* for a wire-named object, and the wire name (prefix + hash) is the only\n* thing ever compared — the hash is never recomputed from an introspected\n* body, so there is no need to match the database's reprinted form. Minimal\n* normalization also protects the no-collision property: aggressive rewriting\n* (lowercasing, paren-stripping, cast-alias folding) risks collapsing two\n* distinct bodies onto one hash.\n*\n* The normalizer is a stability commitment: any change re-suffixes all wire names.\n*/\nfunction normalizeSqlBody(sql) {\n\treturn sql.replace(/\\s+/g, \" \").trim();\n}\n/**\n* Returns the first 8 lowercase hex characters of the SHA-256 digest over the\n* canonical content tuple for a check constraint:\n*\n*   [normalizeSqlBody(expression)]\n*\n* The predicate is the whole of a check's content — the constraint name,\n* schema, and table are orthogonal to its equivalence. The one-element tuple\n* keeps the encoding in the same shape as the index and RLS tuples so a member\n* can be added later without re-reading which encoding a kind uses.\n*\n* The tuple order and encoding are a stability commitment: any change\n* re-suffixes every wire name.\n*/\nfunction computeCheckContentHash(expression) {\n\tconst tuple = JSON.stringify([normalizeSqlBody(expression)]);\n\treturn createHash(\"sha256\").update(tuple).digest(\"hex\").slice(0, 8);\n}\n/** The trailing segment a check's wire-name prefix carries, per kind. */\nconst CHECK_KIND_SUFFIX = {\n\tmembership: \"check\",\n\telementNotNull: \"elem_not_null\"\n};\n/**\n* Composes the wire-name prefix of a derived CHECK constraint:\n* `${table}_${column}_${kindSuffix}`, capped at the wire-name byte budget.\n* Shared by contract authoring (naming emitted checks) and `contract infer`\n* (recomputing the name a derived check would carry), so truncated and\n* multibyte prefixes match by construction.\n*/\nfunction composeCheckWirePrefix(tableName, columnName, kind) {\n\treturn truncateToWireNamePrefixBytes(`${tableName}_${columnName}_${CHECK_KIND_SUFFIX[kind]}`);\n}\n/**\n* Every {@link CheckKind} value, read off {@link CHECK_KIND_SUFFIX}'s own keys\n* so the enumeration can never drift out of step with it.\n*/\nconst CHECK_KINDS = Object.keys(CHECK_KIND_SUFFIX).filter((kind) => kind in CHECK_KIND_SUFFIX);\n/**\n* The wire-name prefixes derivation could produce for `tableName`: every\n* {@link composeCheckWirePrefix} result crossing each of `columnNames` with\n* each {@link CheckKind}. A check is derived iff its prefix is a member of\n* this set.\n*\n* This is the prefix SHAPE only, not the full name-with-hash: it does not\n* know which kind a specific column's type would actually derive (that needs\n* the target's `renderCheckExpressions` hook, which callers of this function\n* do not have in hand), so every column is conservatively treated as capable\n* of producing every kind.\n*/\nfunction derivedCheckPrefixes(tableName, columnNames) {\n\tconst prefixes = /* @__PURE__ */ new Set();\n\tfor (const columnName of columnNames) for (const kind of CHECK_KINDS) prefixes.add(composeCheckWirePrefix(tableName, columnName, kind));\n\treturn prefixes;\n}\n/**\n* Returns the first 8 lowercase hex characters of the SHA-256 digest over the\n* canonical content tuple for an index:\n*\n*   [normalizeSqlBody(expression), normalizeSqlBody(where), columns, unique, type, sortedOptions]\n*\n* Columns hash in authored order — column order is semantic in an index.\n* Option values are `String()`-coerced (matching the loose option equality\n* used for diffing) so a hash computed from typed contract values agrees with\n* one recomputed from introspected reloptions strings. The prefix, schema,\n* and table are excluded (they are orthogonal to index equivalence).\n*\n* The tuple order and encoding are a stability commitment with the same\n* status as the RLS tuple: any change re-suffixes every wire name.\n*/\n/**\n* Canonicalizes one index option VALUE to the `on`/`off` boolean spelling:\n* JS booleans and the common catalog spellings (`pg_class.reloptions`\n* stores whatever spelling the DDL used, so a live index may carry\n* `'true'`/`'false'` or `'on'`/`'off'`) all map to one form; everything\n* else via `String()` (fully specified for numbers, so no platform\n* variance). Shared by the wire-name hash tuple, the node's option\n* equality, and the DDL renderer, so an authored `{ fastupdate: true }`\n* agrees with a live index created under any boolean spelling.\n*/\nfunction normalizeIndexOptionValue(value) {\n\tif (value === true || value === \"true\" || value === \"on\") return \"on\";\n\tif (value === false || value === \"false\" || value === \"off\") return \"off\";\n\treturn String(value);\n}\nfunction computeIndexContentHash(parts) {\n\tconst sortedOptions = Object.entries(parts.options ?? {}).map(([key, value]) => [key, normalizeIndexOptionValue(value)]).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);\n\tconst tuple = JSON.stringify([\n\t\tnormalizeSqlBody(parts.expression ?? \"\"),\n\t\tnormalizeSqlBody(parts.where ?? \"\"),\n\t\tparts.columns ?? [],\n\t\tparts.unique,\n\t\tparts.type ?? \"\",\n\t\tsortedOptions\n\t]);\n\treturn createHash(\"sha256\").update(tuple).digest(\"hex\").slice(0, 8);\n}\n/**\n* Postgres truncates identifiers at `NAMEDATALEN - 1` = 63 **bytes**, not\n* characters, and the wire name appends a 9-byte `_<8hex>` suffix — so a\n* prefix is bounded at 54 bytes. A prefix of non-ASCII characters can sit well\n* under 54 characters and still overrun: the database would silently truncate\n* the name, leaving the declared object permanently unmatchable against the\n* live one.\n*/\nconst WIRE_NAME_PREFIX_MAX_BYTES = 54;\nconst utf8 = new TextEncoder();\n/** UTF-8 byte length — the unit Postgres measures identifiers in. */\nfunction byteLength(value) {\n\treturn utf8.encode(value).length;\n}\n/**\n* Rejects a wire-name prefix over {@link WIRE_NAME_PREFIX_MAX_BYTES}.\n* `subject` opens the error message (e.g. `defineContract: policy prefix`).\n*/\nfunction assertWireNamePrefixLength(prefix, subject) {\n\tif (byteLength(prefix) > 54) throw structuredError(\"CONTRACT.WIRE_NAME_PREFIX_TOO_LONG\", `${subject} \"${prefix}\" exceeds the 54-byte maximum (Postgres identifiers cap at 63 bytes and the wire name appends a 9-byte hash suffix).`, { meta: {\n\t\tprefix,\n\t\tmaxBytes: 54\n\t} });\n}\n/**\n* Shortens a DERIVED wire-name prefix to {@link WIRE_NAME_PREFIX_MAX_BYTES},\n* cutting on a code-point boundary so a multibyte character is never split.\n* Only derived prefixes truncate — an authored one throws\n* ({@link assertWireNamePrefixLength}), because its author can shorten it.\n*/\nfunction truncateToWireNamePrefixBytes(prefix) {\n\tif (byteLength(prefix) <= 54) return prefix;\n\tlet out = \"\";\n\tlet bytes = 0;\n\tfor (const character of prefix) {\n\t\tconst size = byteLength(character);\n\t\tif (bytes + size > 54) break;\n\t\tout += character;\n\t\tbytes += size;\n\t}\n\treturn out;\n}\n//#endregion\nexport { computeIndexContentHash as a, formatWireName as c, namingOfLiveName as d, normalizeIndexOptionValue as f, truncateToWireNamePrefixBytes as g, parseWireName as h, computeCheckContentHash as i, nameOf as l, parseNaming as m, assertWireNamePrefixLength as n, defaultIndexName as o, normalizeSqlBody as p, composeCheckWirePrefix as r, derivedCheckPrefixes as s, WIRE_NAME_PREFIX_MAX_BYTES as t, namingOf as u };\n\n//# sourceMappingURL=naming-DKr4TJd7.mjs.map"],"mappings":"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"}

package/dist/pack-types-BcLTpwbv.d.mts

@@ -1,14 +0,0 @@
-//#region ../../../2-sql/1-core/contract/dist/pack-types.d.mts
-//#region src/pack-types.d.ts
-/**
- * Storage type metadata for pack refs.
- */
-interface StorageTypeMetadata {
-  readonly typeId: string;
-  readonly familyId: string;
-  readonly targetId: string;
-  readonly nativeType?: string;
-}
-//#endregion
-export { StorageTypeMetadata as t };
-//# sourceMappingURL=pack-types-BcLTpwbv.d.mts.map

package/dist/pack-types-BcLTpwbv.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pack-types-BcLTpwbv.d.mts","names":[],"sources":["../../../../2-sql/1-core/contract/dist/pack-types.d.mts"],"mappings":";;;;;UAIU;WACC;WACA;WACA;WACA"}

package/dist/plan-BHLdb0Z7.d.mts

@@ -1,2 +0,0 @@
-import "./plan-CDxduYaN-pLIyyJaB.mjs";
-import "./sql-execution-plan--jKyLpe5-CMGhgO0M.mjs";

package/dist/plan-CDxduYaN-pLIyyJaB.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"plan-CDxduYaN-pLIyyJaB.d.mts","names":[],"sources":["../../../../2-sql/4-lanes/relational-core/dist/plan-CDxduYaN.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;UAkBU,aAAa,uBAAuB,UAAU;WAC7C,KAAK;WACL;;;;;;;;;;;;;;;;;;;;iBAoBM,YAAY,eAAe,KAAK,aAAa,UAAU,SAAS,aAAa,kBAAkB,aAAa"}

package/dist/plan-Dh0LbYIv-Crx5-ThG.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"plan-Dh0LbYIv-Crx5-ThG.mjs","names":[],"sources":["../../../../2-sql/4-lanes/relational-core/dist/plan-Dh0LbYIv.mjs"],"sourcesContent":["//#region src/plan.ts\n/**\n* Wraps an `AnyQueryAst` (typically a `RawQueryAst`, minted by a raw statement\n* terminator or package-internally by an extension's migration factory) in a\n* fully-populated `SqlQueryPlan` whose `meta` is sourced from the supplied\n* contract.\n*\n* Centralising the envelope here means consumers (raw statement terminators,\n* cipherstash migration factories) cannot drift on `storageHash` /\n* `target` / `targetFamily`, which would otherwise surface as a subtle\n* `assertContractMatches` failure inside `dataTransform`. `params` defaults\n* to `[]` because parameters embedded in the AST as `ParamRef`s are resolved\n* at lowering time (`encodeParams` walks `plan.ast.collectParamRefs()`),\n* not at plan-construction time.\n*\n* The default `laneId` of `'raw'` reflects raw-SQL plans' standard lane tag;\n* callers (e.g. a future `sql-raw-factory`) may override to differentiate\n* the plan's provenance.\n*/\nfunction planFromAst(ast, contract, laneId = \"raw\") {\n\treturn {\n\t\tast,\n\t\tparams: [],\n\t\tmeta: {\n\t\t\ttarget: contract.target,\n\t\t\ttargetFamily: contract.targetFamily,\n\t\t\tstorageHash: contract.storage.storageHash,\n\t\t\tlane: laneId\n\t\t}\n\t};\n}\n//#endregion\nexport { planFromAst as t };\n\n//# sourceMappingURL=plan-Dh0LbYIv.mjs.map"],"mappings":";;;;;;;;;;;;;;;;;;;AAmBA,SAAS,YAAY,KAAK,UAAU,SAAS,OAAO;CACnD,OAAO;EACN;EACA,QAAQ,CAAC;EACT,MAAM;GACL,QAAQ,SAAS;GACjB,cAAc,SAAS;GACvB,aAAa,SAAS,QAAQ;GAC9B,MAAM;EACP;CACD;AACD"}

package/dist/prepared-query-BJr50wPm-ChoqfJbX.mjs

@@ -1,22 +0,0 @@
-import { invariant } from "@prisma/orm-framework/utils/assertions";
-//#region ../../../2-sql/5-runtime/dist/prepared-query-BJr50wPm.mjs
-const preparedStatementExecute = Symbol("preparedStatementExecute");
-function isPreparedStatementExecuteTarget(target) {
-	return preparedStatementExecute in target;
-}
-function runPreparedExecute(target, statement, params, options) {
-	invariant(isPreparedStatementExecuteTarget(target), "RuntimeQueryable is missing the prepared statement execute bridge");
-	return target[preparedStatementExecute](statement, params, options);
-}
-const preparedStatementQuery = Symbol("preparedStatementQuery");
-function isPreparedStatementQueryTarget(target) {
-	return preparedStatementQuery in target;
-}
-function runPreparedQuery(target, statement, params, options) {
-	invariant(isPreparedStatementQueryTarget(target), "RuntimeQueryable is missing the prepared statement query bridge");
-	return target[preparedStatementQuery](statement, params, options);
-}
-//#endregion
-export { runPreparedQuery as i, preparedStatementQuery as n, runPreparedExecute as r, preparedStatementExecute as t };
-
-//# sourceMappingURL=prepared-query-BJr50wPm-ChoqfJbX.mjs.map

package/dist/prepared-query-BJr50wPm-ChoqfJbX.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"prepared-query-BJr50wPm-ChoqfJbX.mjs","names":[],"sources":["../../../../2-sql/5-runtime/dist/prepared-query-BJr50wPm.mjs"],"sourcesContent":["import { invariant } from \"@internal/utils/assertions\";\n//#region src/prepared/prepared-execute.ts\nconst preparedStatementExecute = Symbol(\"preparedStatementExecute\");\nfunction isPreparedStatementExecuteTarget(target) {\n\treturn preparedStatementExecute in target;\n}\nfunction runPreparedExecute(target, statement, params, options) {\n\tinvariant(isPreparedStatementExecuteTarget(target), \"RuntimeQueryable is missing the prepared statement execute bridge\");\n\treturn target[preparedStatementExecute](statement, params, options);\n}\n//#endregion\n//#region src/prepared/prepared-query.ts\nconst preparedStatementQuery = Symbol(\"preparedStatementQuery\");\nfunction isPreparedStatementQueryTarget(target) {\n\treturn preparedStatementQuery in target;\n}\nfunction runPreparedQuery(target, statement, params, options) {\n\tinvariant(isPreparedStatementQueryTarget(target), \"RuntimeQueryable is missing the prepared statement query bridge\");\n\treturn target[preparedStatementQuery](statement, params, options);\n}\n//#endregion\nexport { runPreparedExecute as i, runPreparedQuery as n, preparedStatementExecute as r, preparedStatementQuery as t };\n\n//# sourceMappingURL=prepared-query-BJr50wPm.mjs.map"],"mappings":";;AAEA,MAAM,2BAA2B,OAAO,0BAA0B;AAClE,SAAS,iCAAiC,QAAQ;CACjD,OAAO,4BAA4B;AACpC;AACA,SAAS,mBAAmB,QAAQ,WAAW,QAAQ,SAAS;CAC/D,UAAU,iCAAiC,MAAM,GAAG,mEAAmE;CACvH,OAAO,OAAO,yBAAyB,CAAC,WAAW,QAAQ,OAAO;AACnE;AAGA,MAAM,yBAAyB,OAAO,wBAAwB;AAC9D,SAAS,+BAA+B,QAAQ;CAC/C,OAAO,0BAA0B;AAClC;AACA,SAAS,iBAAiB,QAAQ,WAAW,QAAQ,SAAS;CAC7D,UAAU,+BAA+B,MAAM,GAAG,iEAAiE;CACnH,OAAO,OAAO,uBAAuB,CAAC,WAAW,QAAQ,OAAO;AACjE"}