drizzle-orm 1.0.0-beta.1-7722e6a → 1.0.0-beta.2-e93475f

package/cockroach-core/schema.cjs

@@ -0,0 +1,92 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var schema_exports = {};
+__export(schema_exports, {
+  CockroachSchema: () => CockroachSchema,
+  cockroachSchema: () => cockroachSchema,
+  isCockroachSchema: () => isCockroachSchema
+});
+module.exports = __toCommonJS(schema_exports);
+var import_entity = require("../entity.cjs");
+var import_sql = require("../sql/sql.cjs");
+var import_enum = require("./columns/enum.cjs");
+var import_sequence = require("./sequence.cjs");
+var import_table = require("./table.cjs");
+var import_view = require("./view.cjs");
+class CockroachSchema {
+  constructor(schemaName) {
+    this.schemaName = schemaName;
+    this.table = Object.assign(this.table, {
+      withRLS: ((name, columns, extraConfig) => {
+        const table = (0, import_table.cockroachTableWithSchema)(name, columns, extraConfig, this.schemaName);
+        table[import_table.EnableRLS] = true;
+        return table;
+      })
+    });
+  }
+  static [import_entity.entityKind] = "CockroachSchema";
+  isExisting = false;
+  table = ((name, columns, extraConfig) => {
+    return (0, import_table.cockroachTableWithSchema)(name, columns, extraConfig, this.schemaName);
+  });
+  view = ((name, columns) => {
+    return (0, import_view.cockroachViewWithSchema)(name, columns, this.schemaName);
+  });
+  materializedView = ((name, columns) => {
+    return (0, import_view.cockroachMaterializedViewWithSchema)(name, columns, this.schemaName);
+  });
+  enum(enumName, input) {
+    return Array.isArray(input) ? (0, import_enum.cockroachEnumWithSchema)(
+      enumName,
+      [...input],
+      this.schemaName
+    ) : (0, import_enum.cockroachEnumObjectWithSchema)(enumName, input, this.schemaName);
+  }
+  sequence = ((name, options) => {
+    return (0, import_sequence.cockroachSequenceWithSchema)(name, options, this.schemaName);
+  });
+  getSQL() {
+    return new import_sql.SQL([import_sql.sql.identifier(this.schemaName)]);
+  }
+  shouldOmitSQLParens() {
+    return true;
+  }
+  existing() {
+    this.isExisting = true;
+    return this;
+  }
+}
+function isCockroachSchema(obj) {
+  return (0, import_entity.is)(obj, CockroachSchema);
+}
+function cockroachSchema(name) {
+  if (name === "public") {
+    throw new Error(
+      `You can't specify 'public' as schema name. Postgres is using public schema by default. If you want to use 'public' schema, just use cockroachTable() instead of creating a schema`
+    );
+  }
+  return new CockroachSchema(name);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CockroachSchema,
+  cockroachSchema,
+  isCockroachSchema
+});
+//# sourceMappingURL=schema.cjs.map

package/cockroach-core/schema.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/cockroach-core/schema.ts"],"sourcesContent":["import { entityKind, is } from '~/entity.ts';\nimport { SQL, sql, type SQLWrapper } from '~/sql/sql.ts';\nimport type { NonArray, Writable } from '~/utils.ts';\nimport {\n\ttype CockroachEnum,\n\ttype CockroachEnumObject,\n\tcockroachEnumObjectWithSchema,\n\tcockroachEnumWithSchema,\n} from './columns/enum.ts';\nimport { type cockroachSequence, cockroachSequenceWithSchema } from './sequence.ts';\nimport { type CockroachTableFn, type CockroachTableFnInternal, cockroachTableWithSchema, EnableRLS } from './table.ts';\nimport {\n\ttype cockroachMaterializedView,\n\tcockroachMaterializedViewWithSchema,\n\ttype cockroachView,\n\tcockroachViewWithSchema,\n} from './view.ts';\n\nexport class CockroachSchema<TName extends string = string> implements SQLWrapper {\n\tstatic readonly [entityKind]: string = 'CockroachSchema';\n\n\tisExisting: boolean = false;\n\tconstructor(\n\t\tpublic readonly schemaName: TName,\n\t) {\n\t\tthis.table = Object.assign(this.table, {\n\t\t\twithRLS: ((name, columns, extraConfig) => {\n\t\t\t\tconst table = cockroachTableWithSchema(name, columns, extraConfig, this.schemaName);\n\t\t\t\ttable[EnableRLS] = true;\n\n\t\t\t\treturn table;\n\t\t\t}) as CockroachTableFnInternal<TName>,\n\t\t});\n\t}\n\n\ttable: CockroachTableFn<TName> = ((name, columns, extraConfig) => {\n\t\treturn cockroachTableWithSchema(name, columns, extraConfig, this.schemaName);\n\t}) as CockroachTableFn<TName>;\n\n\tview = ((name, columns) => {\n\t\treturn cockroachViewWithSchema(name, columns, this.schemaName);\n\t}) as typeof cockroachView;\n\n\tmaterializedView = ((name, columns) => {\n\t\treturn cockroachMaterializedViewWithSchema(name, columns, this.schemaName);\n\t}) as typeof cockroachMaterializedView;\n\n\tpublic enum<U extends string, T extends Readonly<[U, ...U[]]>>(\n\t\tenumName: string,\n\t\tvalues: T | Writable<T>,\n\t): CockroachEnum<Writable<T>>;\n\n\tpublic enum<E extends Record<string, string>>(\n\t\tenumName: string,\n\t\tenumObj: NonArray<E>,\n\t): CockroachEnumObject<E>;\n\n\tpublic enum(enumName: any, input: any): any {\n\t\treturn Array.isArray(input)\n\t\t\t? cockroachEnumWithSchema(\n\t\t\t\tenumName,\n\t\t\t\t[...input] as [string, ...string[]],\n\t\t\t\tthis.schemaName,\n\t\t\t)\n\t\t\t: cockroachEnumObjectWithSchema(enumName, input, this.schemaName);\n\t}\n\n\tsequence: typeof cockroachSequence = ((name, options) => {\n\t\treturn cockroachSequenceWithSchema(name, options, this.schemaName);\n\t});\n\n\tgetSQL(): SQL {\n\t\treturn new SQL([sql.identifier(this.schemaName)]);\n\t}\n\n\tshouldOmitSQLParens(): boolean {\n\t\treturn true;\n\t}\n\n\texisting(): this {\n\t\tthis.isExisting = true;\n\t\treturn this;\n\t}\n}\n\nexport function isCockroachSchema(obj: unknown): obj is CockroachSchema {\n\treturn is(obj, CockroachSchema);\n}\n\nexport function cockroachSchema<T extends string>(name: T) {\n\tif (name === 'public') {\n\t\tthrow new Error(\n\t\t\t`You can't specify 'public' as schema name. Postgres is using public schema by default. If you want to use 'public' schema, just use cockroachTable() instead of creating a schema`,\n\t\t);\n\t}\n\n\treturn new CockroachSchema(name);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAA+B;AAC/B,iBAA0C;AAE1C,kBAKO;AACP,sBAAoE;AACpE,mBAA0G;AAC1G,kBAKO;AAEA,MAAM,gBAAqE;AAAA,EAIjF,YACiB,YACf;AADe;AAEhB,SAAK,QAAQ,OAAO,OAAO,KAAK,OAAO;AAAA,MACtC,UAAU,CAAC,MAAM,SAAS,gBAAgB;AACzC,cAAM,YAAQ,uCAAyB,MAAM,SAAS,aAAa,KAAK,UAAU;AAClF,cAAM,sBAAS,IAAI;AAEnB,eAAO;AAAA,MACR;AAAA,IACD,CAAC;AAAA,EACF;AAAA,EAdA,QAAiB,wBAAU,IAAY;AAAA,EAEvC,aAAsB;AAAA,EActB,SAAkC,CAAC,MAAM,SAAS,gBAAgB;AACjE,eAAO,uCAAyB,MAAM,SAAS,aAAa,KAAK,UAAU;AAAA,EAC5E;AAAA,EAEA,QAAQ,CAAC,MAAM,YAAY;AAC1B,eAAO,qCAAwB,MAAM,SAAS,KAAK,UAAU;AAAA,EAC9D;AAAA,EAEA,oBAAoB,CAAC,MAAM,YAAY;AACtC,eAAO,iDAAoC,MAAM,SAAS,KAAK,UAAU;AAAA,EAC1E;AAAA,EAYO,KAAK,UAAe,OAAiB;AAC3C,WAAO,MAAM,QAAQ,KAAK,QACvB;AAAA,MACD;AAAA,MACA,CAAC,GAAG,KAAK;AAAA,MACT,KAAK;AAAA,IACN,QACE,2CAA8B,UAAU,OAAO,KAAK,UAAU;AAAA,EAClE;AAAA,EAEA,YAAsC,CAAC,MAAM,YAAY;AACxD,eAAO,6CAA4B,MAAM,SAAS,KAAK,UAAU;AAAA,EAClE;AAAA,EAEA,SAAc;AACb,WAAO,IAAI,eAAI,CAAC,eAAI,WAAW,KAAK,UAAU,CAAC,CAAC;AAAA,EACjD;AAAA,EAEA,sBAA+B;AAC9B,WAAO;AAAA,EACR;AAAA,EAEA,WAAiB;AAChB,SAAK,aAAa;AAClB,WAAO;AAAA,EACR;AACD;AAEO,SAAS,kBAAkB,KAAsC;AACvE,aAAO,kBAAG,KAAK,eAAe;AAC/B;AAEO,SAAS,gBAAkC,MAAS;AAC1D,MAAI,SAAS,UAAU;AACtB,UAAM,IAAI;AAAA,MACT;AAAA,IACD;AAAA,EACD;AAEA,SAAO,IAAI,gBAAgB,IAAI;AAChC;","names":[]}

package/cockroach-core/schema.d.cts

@@ -0,0 +1,24 @@
+import { entityKind } from "../entity.cjs";
+import { SQL, type SQLWrapper } from "../sql/sql.cjs";
+import type { NonArray, Writable } from "../utils.cjs";
+import { type CockroachEnum, type CockroachEnumObject } from "./columns/enum.cjs";
+import { type cockroachSequence } from "./sequence.cjs";
+import { type CockroachTableFn } from "./table.cjs";
+import { type cockroachMaterializedView, type cockroachView } from "./view.cjs";
+export declare class CockroachSchema<TName extends string = string> implements SQLWrapper {
+    readonly schemaName: TName;
+    static readonly [entityKind]: string;
+    isExisting: boolean;
+    constructor(schemaName: TName);
+    table: CockroachTableFn<TName>;
+    view: typeof cockroachView;
+    materializedView: typeof cockroachMaterializedView;
+    enum<U extends string, T extends Readonly<[U, ...U[]]>>(enumName: string, values: T | Writable<T>): CockroachEnum<Writable<T>>;
+    enum<E extends Record<string, string>>(enumName: string, enumObj: NonArray<E>): CockroachEnumObject<E>;
+    sequence: typeof cockroachSequence;
+    getSQL(): SQL;
+    shouldOmitSQLParens(): boolean;
+    existing(): this;
+}
+export declare function isCockroachSchema(obj: unknown): obj is CockroachSchema;
+export declare function cockroachSchema<T extends string>(name: T): CockroachSchema<T>;

package/cockroach-core/schema.d.ts

@@ -0,0 +1,24 @@
+import { entityKind } from "../entity.js";
+import { SQL, type SQLWrapper } from "../sql/sql.js";
+import type { NonArray, Writable } from "../utils.js";
+import { type CockroachEnum, type CockroachEnumObject } from "./columns/enum.js";
+import { type cockroachSequence } from "./sequence.js";
+import { type CockroachTableFn } from "./table.js";
+import { type cockroachMaterializedView, type cockroachView } from "./view.js";
+export declare class CockroachSchema<TName extends string = string> implements SQLWrapper {
+    readonly schemaName: TName;
+    static readonly [entityKind]: string;
+    isExisting: boolean;
+    constructor(schemaName: TName);
+    table: CockroachTableFn<TName>;
+    view: typeof cockroachView;
+    materializedView: typeof cockroachMaterializedView;
+    enum<U extends string, T extends Readonly<[U, ...U[]]>>(enumName: string, values: T | Writable<T>): CockroachEnum<Writable<T>>;
+    enum<E extends Record<string, string>>(enumName: string, enumObj: NonArray<E>): CockroachEnumObject<E>;
+    sequence: typeof cockroachSequence;
+    getSQL(): SQL;
+    shouldOmitSQLParens(): boolean;
+    existing(): this;
+}
+export declare function isCockroachSchema(obj: unknown): obj is CockroachSchema;
+export declare function cockroachSchema<T extends string>(name: T): CockroachSchema<T>;

package/cockroach-core/schema.js

@@ -0,0 +1,72 @@
+import { entityKind, is } from "../entity.js";
+import { SQL, sql } from "../sql/sql.js";
+import {
+  cockroachEnumObjectWithSchema,
+  cockroachEnumWithSchema
+} from "./columns/enum.js";
+import { cockroachSequenceWithSchema } from "./sequence.js";
+import { cockroachTableWithSchema, EnableRLS } from "./table.js";
+import {
+  cockroachMaterializedViewWithSchema,
+  cockroachViewWithSchema
+} from "./view.js";
+class CockroachSchema {
+  constructor(schemaName) {
+    this.schemaName = schemaName;
+    this.table = Object.assign(this.table, {
+      withRLS: ((name, columns, extraConfig) => {
+        const table = cockroachTableWithSchema(name, columns, extraConfig, this.schemaName);
+        table[EnableRLS] = true;
+        return table;
+      })
+    });
+  }
+  static [entityKind] = "CockroachSchema";
+  isExisting = false;
+  table = ((name, columns, extraConfig) => {
+    return cockroachTableWithSchema(name, columns, extraConfig, this.schemaName);
+  });
+  view = ((name, columns) => {
+    return cockroachViewWithSchema(name, columns, this.schemaName);
+  });
+  materializedView = ((name, columns) => {
+    return cockroachMaterializedViewWithSchema(name, columns, this.schemaName);
+  });
+  enum(enumName, input) {
+    return Array.isArray(input) ? cockroachEnumWithSchema(
+      enumName,
+      [...input],
+      this.schemaName
+    ) : cockroachEnumObjectWithSchema(enumName, input, this.schemaName);
+  }
+  sequence = ((name, options) => {
+    return cockroachSequenceWithSchema(name, options, this.schemaName);
+  });
+  getSQL() {
+    return new SQL([sql.identifier(this.schemaName)]);
+  }
+  shouldOmitSQLParens() {
+    return true;
+  }
+  existing() {
+    this.isExisting = true;
+    return this;
+  }
+}
+function isCockroachSchema(obj) {
+  return is(obj, CockroachSchema);
+}
+function cockroachSchema(name) {
+  if (name === "public") {
+    throw new Error(
+      `You can't specify 'public' as schema name. Postgres is using public schema by default. If you want to use 'public' schema, just use cockroachTable() instead of creating a schema`
+    );
+  }
+  return new CockroachSchema(name);
+}
+export {
+  CockroachSchema,
+  cockroachSchema,
+  isCockroachSchema
+};
+//# sourceMappingURL=schema.js.map

package/cockroach-core/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/cockroach-core/schema.ts"],"sourcesContent":["import { entityKind, is } from '~/entity.ts';\nimport { SQL, sql, type SQLWrapper } from '~/sql/sql.ts';\nimport type { NonArray, Writable } from '~/utils.ts';\nimport {\n\ttype CockroachEnum,\n\ttype CockroachEnumObject,\n\tcockroachEnumObjectWithSchema,\n\tcockroachEnumWithSchema,\n} from './columns/enum.ts';\nimport { type cockroachSequence, cockroachSequenceWithSchema } from './sequence.ts';\nimport { type CockroachTableFn, type CockroachTableFnInternal, cockroachTableWithSchema, EnableRLS } from './table.ts';\nimport {\n\ttype cockroachMaterializedView,\n\tcockroachMaterializedViewWithSchema,\n\ttype cockroachView,\n\tcockroachViewWithSchema,\n} from './view.ts';\n\nexport class CockroachSchema<TName extends string = string> implements SQLWrapper {\n\tstatic readonly [entityKind]: string = 'CockroachSchema';\n\n\tisExisting: boolean = false;\n\tconstructor(\n\t\tpublic readonly schemaName: TName,\n\t) {\n\t\tthis.table = Object.assign(this.table, {\n\t\t\twithRLS: ((name, columns, extraConfig) => {\n\t\t\t\tconst table = cockroachTableWithSchema(name, columns, extraConfig, this.schemaName);\n\t\t\t\ttable[EnableRLS] = true;\n\n\t\t\t\treturn table;\n\t\t\t}) as CockroachTableFnInternal<TName>,\n\t\t});\n\t}\n\n\ttable: CockroachTableFn<TName> = ((name, columns, extraConfig) => {\n\t\treturn cockroachTableWithSchema(name, columns, extraConfig, this.schemaName);\n\t}) as CockroachTableFn<TName>;\n\n\tview = ((name, columns) => {\n\t\treturn cockroachViewWithSchema(name, columns, this.schemaName);\n\t}) as typeof cockroachView;\n\n\tmaterializedView = ((name, columns) => {\n\t\treturn cockroachMaterializedViewWithSchema(name, columns, this.schemaName);\n\t}) as typeof cockroachMaterializedView;\n\n\tpublic enum<U extends string, T extends Readonly<[U, ...U[]]>>(\n\t\tenumName: string,\n\t\tvalues: T | Writable<T>,\n\t): CockroachEnum<Writable<T>>;\n\n\tpublic enum<E extends Record<string, string>>(\n\t\tenumName: string,\n\t\tenumObj: NonArray<E>,\n\t): CockroachEnumObject<E>;\n\n\tpublic enum(enumName: any, input: any): any {\n\t\treturn Array.isArray(input)\n\t\t\t? cockroachEnumWithSchema(\n\t\t\t\tenumName,\n\t\t\t\t[...input] as [string, ...string[]],\n\t\t\t\tthis.schemaName,\n\t\t\t)\n\t\t\t: cockroachEnumObjectWithSchema(enumName, input, this.schemaName);\n\t}\n\n\tsequence: typeof cockroachSequence = ((name, options) => {\n\t\treturn cockroachSequenceWithSchema(name, options, this.schemaName);\n\t});\n\n\tgetSQL(): SQL {\n\t\treturn new SQL([sql.identifier(this.schemaName)]);\n\t}\n\n\tshouldOmitSQLParens(): boolean {\n\t\treturn true;\n\t}\n\n\texisting(): this {\n\t\tthis.isExisting = true;\n\t\treturn this;\n\t}\n}\n\nexport function isCockroachSchema(obj: unknown): obj is CockroachSchema {\n\treturn is(obj, CockroachSchema);\n}\n\nexport function cockroachSchema<T extends string>(name: T) {\n\tif (name === 'public') {\n\t\tthrow new Error(\n\t\t\t`You can't specify 'public' as schema name. Postgres is using public schema by default. If you want to use 'public' schema, just use cockroachTable() instead of creating a schema`,\n\t\t);\n\t}\n\n\treturn new CockroachSchema(name);\n}\n"],"mappings":"AAAA,SAAS,YAAY,UAAU;AAC/B,SAAS,KAAK,WAA4B;AAE1C;AAAA,EAGC;AAAA,EACA;AAAA,OACM;AACP,SAAiC,mCAAmC;AACpE,SAA+D,0BAA0B,iBAAiB;AAC1G;AAAA,EAEC;AAAA,EAEA;AAAA,OACM;AAEA,MAAM,gBAAqE;AAAA,EAIjF,YACiB,YACf;AADe;AAEhB,SAAK,QAAQ,OAAO,OAAO,KAAK,OAAO;AAAA,MACtC,UAAU,CAAC,MAAM,SAAS,gBAAgB;AACzC,cAAM,QAAQ,yBAAyB,MAAM,SAAS,aAAa,KAAK,UAAU;AAClF,cAAM,SAAS,IAAI;AAEnB,eAAO;AAAA,MACR;AAAA,IACD,CAAC;AAAA,EACF;AAAA,EAdA,QAAiB,UAAU,IAAY;AAAA,EAEvC,aAAsB;AAAA,EActB,SAAkC,CAAC,MAAM,SAAS,gBAAgB;AACjE,WAAO,yBAAyB,MAAM,SAAS,aAAa,KAAK,UAAU;AAAA,EAC5E;AAAA,EAEA,QAAQ,CAAC,MAAM,YAAY;AAC1B,WAAO,wBAAwB,MAAM,SAAS,KAAK,UAAU;AAAA,EAC9D;AAAA,EAEA,oBAAoB,CAAC,MAAM,YAAY;AACtC,WAAO,oCAAoC,MAAM,SAAS,KAAK,UAAU;AAAA,EAC1E;AAAA,EAYO,KAAK,UAAe,OAAiB;AAC3C,WAAO,MAAM,QAAQ,KAAK,IACvB;AAAA,MACD;AAAA,MACA,CAAC,GAAG,KAAK;AAAA,MACT,KAAK;AAAA,IACN,IACE,8BAA8B,UAAU,OAAO,KAAK,UAAU;AAAA,EAClE;AAAA,EAEA,YAAsC,CAAC,MAAM,YAAY;AACxD,WAAO,4BAA4B,MAAM,SAAS,KAAK,UAAU;AAAA,EAClE;AAAA,EAEA,SAAc;AACb,WAAO,IAAI,IAAI,CAAC,IAAI,WAAW,KAAK,UAAU,CAAC,CAAC;AAAA,EACjD;AAAA,EAEA,sBAA+B;AAC9B,WAAO;AAAA,EACR;AAAA,EAEA,WAAiB;AAChB,SAAK,aAAa;AAClB,WAAO;AAAA,EACR;AACD;AAEO,SAAS,kBAAkB,KAAsC;AACvE,SAAO,GAAG,KAAK,eAAe;AAC/B;AAEO,SAAS,gBAAkC,MAAS;AAC1D,MAAI,SAAS,UAAU;AACtB,UAAM,IAAI;AAAA,MACT;AAAA,IACD;AAAA,EACD;AAEA,SAAO,IAAI,gBAAgB,IAAI;AAChC;","names":[]}

package/cockroach-core/sequence.cjs

@@ -0,0 +1,52 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sequence_exports = {};
+__export(sequence_exports, {
+  CockroachSequence: () => CockroachSequence,
+  cockroachSequence: () => cockroachSequence,
+  cockroachSequenceWithSchema: () => cockroachSequenceWithSchema,
+  isCockroachSequence: () => isCockroachSequence
+});
+module.exports = __toCommonJS(sequence_exports);
+var import_entity = require("../entity.cjs");
+class CockroachSequence {
+  constructor(seqName, seqOptions, schema) {
+    this.seqName = seqName;
+    this.seqOptions = seqOptions;
+    this.schema = schema;
+  }
+  static [import_entity.entityKind] = "CockroachSequence";
+}
+function cockroachSequence(name, options) {
+  return cockroachSequenceWithSchema(name, options, void 0);
+}
+function cockroachSequenceWithSchema(name, options, schema) {
+  return new CockroachSequence(name, options, schema);
+}
+function isCockroachSequence(obj) {
+  return (0, import_entity.is)(obj, CockroachSequence);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CockroachSequence,
+  cockroachSequence,
+  cockroachSequenceWithSchema,
+  isCockroachSequence
+});
+//# sourceMappingURL=sequence.cjs.map

package/cockroach-core/sequence.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/cockroach-core/sequence.ts"],"sourcesContent":["import { entityKind, is } from '~/entity.ts';\n\nexport type CockroachSequenceOptions = {\n\tincrement?: number | string;\n\tminValue?: number | string;\n\tmaxValue?: number | string;\n\tstartWith?: number | string;\n\tcache?: number | string;\n};\n\nexport class CockroachSequence {\n\tstatic readonly [entityKind]: string = 'CockroachSequence';\n\n\tconstructor(\n\t\tpublic readonly seqName: string,\n\t\tpublic readonly seqOptions: CockroachSequenceOptions | undefined,\n\t\tpublic readonly schema: string | undefined,\n\t) {\n\t}\n}\n\nexport function cockroachSequence(\n\tname: string,\n\toptions?: CockroachSequenceOptions,\n): CockroachSequence {\n\treturn cockroachSequenceWithSchema(name, options, undefined);\n}\n\n/** @internal */\nexport function cockroachSequenceWithSchema(\n\tname: string,\n\toptions?: CockroachSequenceOptions,\n\tschema?: string,\n): CockroachSequence {\n\treturn new CockroachSequence(name, options, schema);\n}\n\nexport function isCockroachSequence(obj: unknown): obj is CockroachSequence {\n\treturn is(obj, CockroachSequence);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAA+B;AAUxB,MAAM,kBAAkB;AAAA,EAG9B,YACiB,SACA,YACA,QACf;AAHe;AACA;AACA;AAAA,EAEjB;AAAA,EAPA,QAAiB,wBAAU,IAAY;AAQxC;AAEO,SAAS,kBACf,MACA,SACoB;AACpB,SAAO,4BAA4B,MAAM,SAAS,MAAS;AAC5D;AAGO,SAAS,4BACf,MACA,SACA,QACoB;AACpB,SAAO,IAAI,kBAAkB,MAAM,SAAS,MAAM;AACnD;AAEO,SAAS,oBAAoB,KAAwC;AAC3E,aAAO,kBAAG,KAAK,iBAAiB;AACjC;","names":[]}

package/cockroach-core/sequence.d.cts

@@ -0,0 +1,17 @@
+import { entityKind } from "../entity.cjs";
+export type CockroachSequenceOptions = {
+    increment?: number | string;
+    minValue?: number | string;
+    maxValue?: number | string;
+    startWith?: number | string;
+    cache?: number | string;
+};
+export declare class CockroachSequence {
+    readonly seqName: string;
+    readonly seqOptions: CockroachSequenceOptions | undefined;
+    readonly schema: string | undefined;
+    static readonly [entityKind]: string;
+    constructor(seqName: string, seqOptions: CockroachSequenceOptions | undefined, schema: string | undefined);
+}
+export declare function cockroachSequence(name: string, options?: CockroachSequenceOptions): CockroachSequence;
+export declare function isCockroachSequence(obj: unknown): obj is CockroachSequence;

package/cockroach-core/sequence.d.ts

@@ -0,0 +1,17 @@
+import { entityKind } from "../entity.js";
+export type CockroachSequenceOptions = {
+    increment?: number | string;
+    minValue?: number | string;
+    maxValue?: number | string;
+    startWith?: number | string;
+    cache?: number | string;
+};
+export declare class CockroachSequence {
+    readonly seqName: string;
+    readonly seqOptions: CockroachSequenceOptions | undefined;
+    readonly schema: string | undefined;
+    static readonly [entityKind]: string;
+    constructor(seqName: string, seqOptions: CockroachSequenceOptions | undefined, schema: string | undefined);
+}
+export declare function cockroachSequence(name: string, options?: CockroachSequenceOptions): CockroachSequence;
+export declare function isCockroachSequence(obj: unknown): obj is CockroachSequence;

package/cockroach-core/sequence.js

@@ -0,0 +1,25 @@
+import { entityKind, is } from "../entity.js";
+class CockroachSequence {
+  constructor(seqName, seqOptions, schema) {
+    this.seqName = seqName;
+    this.seqOptions = seqOptions;
+    this.schema = schema;
+  }
+  static [entityKind] = "CockroachSequence";
+}
+function cockroachSequence(name, options) {
+  return cockroachSequenceWithSchema(name, options, void 0);
+}
+function cockroachSequenceWithSchema(name, options, schema) {
+  return new CockroachSequence(name, options, schema);
+}
+function isCockroachSequence(obj) {
+  return is(obj, CockroachSequence);
+}
+export {
+  CockroachSequence,
+  cockroachSequence,
+  cockroachSequenceWithSchema,
+  isCockroachSequence
+};
+//# sourceMappingURL=sequence.js.map

package/cockroach-core/sequence.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/cockroach-core/sequence.ts"],"sourcesContent":["import { entityKind, is } from '~/entity.ts';\n\nexport type CockroachSequenceOptions = {\n\tincrement?: number | string;\n\tminValue?: number | string;\n\tmaxValue?: number | string;\n\tstartWith?: number | string;\n\tcache?: number | string;\n};\n\nexport class CockroachSequence {\n\tstatic readonly [entityKind]: string = 'CockroachSequence';\n\n\tconstructor(\n\t\tpublic readonly seqName: string,\n\t\tpublic readonly seqOptions: CockroachSequenceOptions | undefined,\n\t\tpublic readonly schema: string | undefined,\n\t) {\n\t}\n}\n\nexport function cockroachSequence(\n\tname: string,\n\toptions?: CockroachSequenceOptions,\n): CockroachSequence {\n\treturn cockroachSequenceWithSchema(name, options, undefined);\n}\n\n/** @internal */\nexport function cockroachSequenceWithSchema(\n\tname: string,\n\toptions?: CockroachSequenceOptions,\n\tschema?: string,\n): CockroachSequence {\n\treturn new CockroachSequence(name, options, schema);\n}\n\nexport function isCockroachSequence(obj: unknown): obj is CockroachSequence {\n\treturn is(obj, CockroachSequence);\n}\n"],"mappings":"AAAA,SAAS,YAAY,UAAU;AAUxB,MAAM,kBAAkB;AAAA,EAG9B,YACiB,SACA,YACA,QACf;AAHe;AACA;AACA;AAAA,EAEjB;AAAA,EAPA,QAAiB,UAAU,IAAY;AAQxC;AAEO,SAAS,kBACf,MACA,SACoB;AACpB,SAAO,4BAA4B,MAAM,SAAS,MAAS;AAC5D;AAGO,SAAS,4BACf,MACA,SACA,QACoB;AACpB,SAAO,IAAI,kBAAkB,MAAM,SAAS,MAAM;AACnD;AAEO,SAAS,oBAAoB,KAAwC;AAC3E,SAAO,GAAG,KAAK,iBAAiB;AACjC;","names":[]}

package/cockroach-core/session.cjs

@@ -0,0 +1,120 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var session_exports = {};
+__export(session_exports, {
+  CockroachPreparedQuery: () => CockroachPreparedQuery,
+  CockroachSession: () => CockroachSession,
+  CockroachTransaction: () => CockroachTransaction
+});
+module.exports = __toCommonJS(session_exports);
+var import_entity = require("../entity.cjs");
+var import_errors = require("../errors.cjs");
+var import_sql = require("../sql/index.cjs");
+var import_tracing = require("../tracing.cjs");
+var import_db = require("./db.cjs");
+class CockroachPreparedQuery {
+  constructor(query) {
+    this.query = query;
+  }
+  authToken;
+  getQuery() {
+    return this.query;
+  }
+  mapResult(response, _isFromBatch) {
+    return response;
+  }
+  /** @internal */
+  setToken(token) {
+    this.authToken = token;
+    return this;
+  }
+  static [import_entity.entityKind] = "CockroachPreparedQuery";
+  /** @internal */
+  joinsNotNullableMap;
+}
+class CockroachSession {
+  constructor(dialect) {
+    this.dialect = dialect;
+  }
+  static [import_entity.entityKind] = "CockroachSession";
+  /** @internal */
+  execute(query, token) {
+    return import_tracing.tracer.startActiveSpan("drizzle.operation", () => {
+      const prepared = import_tracing.tracer.startActiveSpan("drizzle.prepareQuery", () => {
+        return this.prepareQuery(
+          this.dialect.sqlToQuery(query),
+          void 0,
+          void 0,
+          false
+        );
+      });
+      return prepared.setToken(token).execute(void 0, token);
+    });
+  }
+  all(query) {
+    return this.prepareQuery(
+      this.dialect.sqlToQuery(query),
+      void 0,
+      void 0,
+      false
+    ).all();
+  }
+  /** @internal */
+  async count(sql2, token) {
+    const res = await this.execute(sql2, token);
+    return Number(
+      res[0]["count"]
+    );
+  }
+}
+class CockroachTransaction extends import_db.CockroachDatabase {
+  constructor(dialect, session, schema, nestedIndex = 0) {
+    super(dialect, session, schema);
+    this.schema = schema;
+    this.nestedIndex = nestedIndex;
+  }
+  static [import_entity.entityKind] = "CockroachTransaction";
+  rollback() {
+    throw new import_errors.TransactionRollbackError();
+  }
+  /** @internal */
+  getTransactionConfigSQL(config) {
+    const chunks = [];
+    if (config.isolationLevel) {
+      chunks.push(`isolation level ${config.isolationLevel}`);
+    }
+    if (config.accessMode) {
+      chunks.push(config.accessMode);
+    }
+    if (typeof config.deferrable === "boolean") {
+      chunks.push(config.deferrable ? "deferrable" : "not deferrable");
+    }
+    return import_sql.sql.raw(chunks.join(" "));
+  }
+  setTransaction(config) {
+    return this.session.execute(import_sql.sql`set transaction ${this.getTransactionConfigSQL(config)}`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CockroachPreparedQuery,
+  CockroachSession,
+  CockroachTransaction
+});
+//# sourceMappingURL=session.cjs.map

package/cockroach-core/session.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/cockroach-core/session.ts"],"sourcesContent":["import type * as V1 from '~/_relations.ts';\nimport { entityKind } from '~/entity.ts';\nimport { TransactionRollbackError } from '~/errors.ts';\nimport type { PreparedQuery } from '~/session.ts';\nimport { type Query, type SQL, sql } from '~/sql/index.ts';\nimport { tracer } from '~/tracing.ts';\nimport type { NeonAuthToken } from '~/utils.ts';\nimport { CockroachDatabase } from './db.ts';\nimport type { CockroachDialect } from './dialect.ts';\nimport type { SelectedFieldsOrdered } from './query-builders/select.types.ts';\n\nexport interface PreparedQueryConfig {\n\texecute: unknown;\n\tall: unknown;\n\tvalues: unknown;\n}\n\nexport abstract class CockroachPreparedQuery<T extends PreparedQueryConfig> implements PreparedQuery {\n\tconstructor(protected query: Query) {}\n\n\tprotected authToken?: NeonAuthToken;\n\n\tgetQuery(): Query {\n\t\treturn this.query;\n\t}\n\n\tmapResult(response: unknown, _isFromBatch?: boolean): unknown {\n\t\treturn response;\n\t}\n\n\t/** @internal */\n\tsetToken(token?: NeonAuthToken) {\n\t\tthis.authToken = token;\n\t\treturn this;\n\t}\n\n\tstatic readonly [entityKind]: string = 'CockroachPreparedQuery';\n\n\t/** @internal */\n\tjoinsNotNullableMap?: Record<string, boolean>;\n\n\tabstract execute(placeholderValues?: Record<string, unknown>): Promise<T['execute']>;\n\t/** @internal */\n\tabstract execute(placeholderValues?: Record<string, unknown>, token?: NeonAuthToken): Promise<T['execute']>;\n\t/** @internal */\n\tabstract execute(placeholderValues?: Record<string, unknown>, token?: NeonAuthToken): Promise<T['execute']>;\n\n\t/** @internal */\n\tabstract all(placeholderValues?: Record<string, unknown>): Promise<T['all']>;\n\n\t/** @internal */\n\tabstract isResponseInArrayMode(): boolean;\n}\n\nexport interface CockroachTransactionConfig {\n\tisolationLevel?: 'read uncommitted' | 'read committed' | 'repeatable read' | 'serializable';\n\taccessMode?: 'read only' | 'read write';\n\tdeferrable?: boolean;\n}\n\nexport abstract class CockroachSession<\n\tTQueryResult extends CockroachQueryResultHKT = CockroachQueryResultHKT,\n\tTFullSchema extends Record<string, unknown> = Record<string, never>,\n\tTSchema extends V1.TablesRelationalConfig = Record<string, never>,\n> {\n\tstatic readonly [entityKind]: string = 'CockroachSession';\n\n\tconstructor(protected dialect: CockroachDialect) {}\n\n\tabstract prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(\n\t\tquery: Query,\n\t\tfields: SelectedFieldsOrdered | undefined,\n\t\tname: string | undefined,\n\t\tisResponseInArrayMode: boolean,\n\t\tcustomResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => T['execute'],\n\t): CockroachPreparedQuery<T>;\n\n\texecute<T>(query: SQL): Promise<T>;\n\t/** @internal */\n\texecute<T>(query: SQL, token?: NeonAuthToken): Promise<T>;\n\t/** @internal */\n\texecute<T>(query: SQL, token?: NeonAuthToken): Promise<T> {\n\t\treturn tracer.startActiveSpan('drizzle.operation', () => {\n\t\t\tconst prepared = tracer.startActiveSpan('drizzle.prepareQuery', () => {\n\t\t\t\treturn this.prepareQuery<PreparedQueryConfig & { execute: T }>(\n\t\t\t\t\tthis.dialect.sqlToQuery(query),\n\t\t\t\t\tundefined,\n\t\t\t\t\tundefined,\n\t\t\t\t\tfalse,\n\t\t\t\t);\n\t\t\t});\n\n\t\t\treturn prepared.setToken(token).execute(undefined, token);\n\t\t});\n\t}\n\n\tall<T = unknown>(query: SQL): Promise<T[]> {\n\t\treturn this.prepareQuery<PreparedQueryConfig & { all: T[] }>(\n\t\t\tthis.dialect.sqlToQuery(query),\n\t\t\tundefined,\n\t\t\tundefined,\n\t\t\tfalse,\n\t\t).all();\n\t}\n\n\tasync count(sql: SQL): Promise<number>;\n\t/** @internal */\n\tasync count(sql: SQL, token?: NeonAuthToken): Promise<number>;\n\t/** @internal */\n\tasync count(sql: SQL, token?: NeonAuthToken): Promise<number> {\n\t\tconst res = await this.execute<[{ count: string }]>(sql, token);\n\n\t\treturn Number(\n\t\t\tres[0]['count'],\n\t\t);\n\t}\n\n\tabstract transaction<T>(\n\t\ttransaction: (tx: CockroachTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>,\n\t\tconfig?: CockroachTransactionConfig,\n\t): Promise<T>;\n}\n\nexport abstract class CockroachTransaction<\n\tTQueryResult extends CockroachQueryResultHKT,\n\tTFullSchema extends Record<string, unknown> = Record<string, never>,\n\tTSchema extends V1.TablesRelationalConfig = Record<string, never>,\n> extends CockroachDatabase<TQueryResult, TFullSchema, TSchema> {\n\tstatic override readonly [entityKind]: string = 'CockroachTransaction';\n\n\tconstructor(\n\t\tdialect: CockroachDialect,\n\t\tsession: CockroachSession<any, any, any>,\n\t\tprotected schema: {\n\t\t\tfullSchema: Record<string, unknown>;\n\t\t\tschema: TSchema;\n\t\t\ttableNamesMap: Record<string, string>;\n\t\t} | undefined,\n\t\tprotected readonly nestedIndex = 0,\n\t) {\n\t\tsuper(dialect, session, schema);\n\t}\n\n\trollback(): never {\n\t\tthrow new TransactionRollbackError();\n\t}\n\n\t/** @internal */\n\tgetTransactionConfigSQL(config: CockroachTransactionConfig): SQL {\n\t\tconst chunks: string[] = [];\n\t\tif (config.isolationLevel) {\n\t\t\tchunks.push(`isolation level ${config.isolationLevel}`);\n\t\t}\n\t\tif (config.accessMode) {\n\t\t\tchunks.push(config.accessMode);\n\t\t}\n\t\tif (typeof config.deferrable === 'boolean') {\n\t\t\tchunks.push(config.deferrable ? 'deferrable' : 'not deferrable');\n\t\t}\n\t\treturn sql.raw(chunks.join(' '));\n\t}\n\n\tsetTransaction(config: CockroachTransactionConfig): Promise<void> {\n\t\treturn this.session.execute(sql`set transaction ${this.getTransactionConfigSQL(config)}`);\n\t}\n\n\tabstract override transaction<T>(\n\t\ttransaction: (tx: CockroachTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>,\n\t): Promise<T>;\n}\n\nexport interface CockroachQueryResultHKT {\n\treadonly $brand: 'CockroachQueryResultHKT';\n\treadonly row: unknown;\n\treadonly type: unknown;\n}\n\nexport type CockroachQueryResultKind<TKind extends CockroachQueryResultHKT, TRow> = (TKind & {\n\treadonly row: TRow;\n})['type'];\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,oBAA2B;AAC3B,oBAAyC;AAEzC,iBAA0C;AAC1C,qBAAuB;AAEvB,gBAAkC;AAU3B,MAAe,uBAA+E;AAAA,EACpG,YAAsB,OAAc;AAAd;AAAA,EAAe;AAAA,EAE3B;AAAA,EAEV,WAAkB;AACjB,WAAO,KAAK;AAAA,EACb;AAAA,EAEA,UAAU,UAAmB,cAAiC;AAC7D,WAAO;AAAA,EACR;AAAA;AAAA,EAGA,SAAS,OAAuB;AAC/B,SAAK,YAAY;AACjB,WAAO;AAAA,EACR;AAAA,EAEA,QAAiB,wBAAU,IAAY;AAAA;AAAA,EAGvC;AAaD;AAQO,MAAe,iBAIpB;AAAA,EAGD,YAAsB,SAA2B;AAA3B;AAAA,EAA4B;AAAA,EAFlD,QAAiB,wBAAU,IAAY;AAAA;AAAA,EAgBvC,QAAW,OAAY,OAAmC;AACzD,WAAO,sBAAO,gBAAgB,qBAAqB,MAAM;AACxD,YAAM,WAAW,sBAAO,gBAAgB,wBAAwB,MAAM;AACrE,eAAO,KAAK;AAAA,UACX,KAAK,QAAQ,WAAW,KAAK;AAAA,UAC7B;AAAA,UACA;AAAA,UACA;AAAA,QACD;AAAA,MACD,CAAC;AAED,aAAO,SAAS,SAAS,KAAK,EAAE,QAAQ,QAAW,KAAK;AAAA,IACzD,CAAC;AAAA,EACF;AAAA,EAEA,IAAiB,OAA0B;AAC1C,WAAO,KAAK;AAAA,MACX,KAAK,QAAQ,WAAW,KAAK;AAAA,MAC7B;AAAA,MACA;AAAA,MACA;AAAA,IACD,EAAE,IAAI;AAAA,EACP;AAAA;AAAA,EAMA,MAAM,MAAMA,MAAU,OAAwC;AAC7D,UAAM,MAAM,MAAM,KAAK,QAA6BA,MAAK,KAAK;AAE9D,WAAO;AAAA,MACN,IAAI,CAAC,EAAE,OAAO;AAAA,IACf;AAAA,EACD;AAMD;AAEO,MAAe,6BAIZ,4BAAsD;AAAA,EAG/D,YACC,SACA,SACU,QAKS,cAAc,GAChC;AACD,UAAM,SAAS,SAAS,MAAM;AAPpB;AAKS;AAAA,EAGpB;AAAA,EAbA,QAA0B,wBAAU,IAAY;AAAA,EAehD,WAAkB;AACjB,UAAM,IAAI,uCAAyB;AAAA,EACpC;AAAA;AAAA,EAGA,wBAAwB,QAAyC;AAChE,UAAM,SAAmB,CAAC;AAC1B,QAAI,OAAO,gBAAgB;AAC1B,aAAO,KAAK,mBAAmB,OAAO,cAAc,EAAE;AAAA,IACvD;AACA,QAAI,OAAO,YAAY;AACtB,aAAO,KAAK,OAAO,UAAU;AAAA,IAC9B;AACA,QAAI,OAAO,OAAO,eAAe,WAAW;AAC3C,aAAO,KAAK,OAAO,aAAa,eAAe,gBAAgB;AAAA,IAChE;AACA,WAAO,eAAI,IAAI,OAAO,KAAK,GAAG,CAAC;AAAA,EAChC;AAAA,EAEA,eAAe,QAAmD;AACjE,WAAO,KAAK,QAAQ,QAAQ,iCAAsB,KAAK,wBAAwB,MAAM,CAAC,EAAE;AAAA,EACzF;AAKD;","names":["sql"]}

package/cockroach-core/session.d.cts

@@ -0,0 +1,62 @@
+import type * as V1 from "../_relations.cjs";
+import { entityKind } from "../entity.cjs";
+import type { PreparedQuery } from "../session.cjs";
+import { type Query, type SQL } from "../sql/index.cjs";
+import type { NeonAuthToken } from "../utils.cjs";
+import { CockroachDatabase } from "./db.cjs";
+import type { CockroachDialect } from "./dialect.cjs";
+import type { SelectedFieldsOrdered } from "./query-builders/select.types.cjs";
+export interface PreparedQueryConfig {
+    execute: unknown;
+    all: unknown;
+    values: unknown;
+}
+export declare abstract class CockroachPreparedQuery<T extends PreparedQueryConfig> implements PreparedQuery {
+    protected query: Query;
+    constructor(query: Query);
+    protected authToken?: NeonAuthToken;
+    getQuery(): Query;
+    mapResult(response: unknown, _isFromBatch?: boolean): unknown;
+    static readonly [entityKind]: string;
+    abstract execute(placeholderValues?: Record<string, unknown>): Promise<T['execute']>;
+}
+export interface CockroachTransactionConfig {
+    isolationLevel?: 'read uncommitted' | 'read committed' | 'repeatable read' | 'serializable';
+    accessMode?: 'read only' | 'read write';
+    deferrable?: boolean;
+}
+export declare abstract class CockroachSession<TQueryResult extends CockroachQueryResultHKT = CockroachQueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends V1.TablesRelationalConfig = Record<string, never>> {
+    protected dialect: CockroachDialect;
+    static readonly [entityKind]: string;
+    constructor(dialect: CockroachDialect);
+    abstract prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(query: Query, fields: SelectedFieldsOrdered | undefined, name: string | undefined, isResponseInArrayMode: boolean, customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => T['execute']): CockroachPreparedQuery<T>;
+    execute<T>(query: SQL): Promise<T>;
+    all<T = unknown>(query: SQL): Promise<T[]>;
+    count(sql: SQL): Promise<number>;
+    abstract transaction<T>(transaction: (tx: CockroachTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>, config?: CockroachTransactionConfig): Promise<T>;
+}
+export declare abstract class CockroachTransaction<TQueryResult extends CockroachQueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends V1.TablesRelationalConfig = Record<string, never>> extends CockroachDatabase<TQueryResult, TFullSchema, TSchema> {
+    protected schema: {
+        fullSchema: Record<string, unknown>;
+        schema: TSchema;
+        tableNamesMap: Record<string, string>;
+    } | undefined;
+    protected readonly nestedIndex: number;
+    static readonly [entityKind]: string;
+    constructor(dialect: CockroachDialect, session: CockroachSession<any, any, any>, schema: {
+        fullSchema: Record<string, unknown>;
+        schema: TSchema;
+        tableNamesMap: Record<string, string>;
+    } | undefined, nestedIndex?: number);
+    rollback(): never;
+    setTransaction(config: CockroachTransactionConfig): Promise<void>;
+    abstract transaction<T>(transaction: (tx: CockroachTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>): Promise<T>;
+}
+export interface CockroachQueryResultHKT {
+    readonly $brand: 'CockroachQueryResultHKT';
+    readonly row: unknown;
+    readonly type: unknown;
+}
+export type CockroachQueryResultKind<TKind extends CockroachQueryResultHKT, TRow> = (TKind & {
+    readonly row: TRow;
+})['type'];

package/cockroach-core/session.d.ts

@@ -0,0 +1,62 @@
+import type * as V1 from "../_relations.js";
+import { entityKind } from "../entity.js";
+import type { PreparedQuery } from "../session.js";
+import { type Query, type SQL } from "../sql/index.js";
+import type { NeonAuthToken } from "../utils.js";
+import { CockroachDatabase } from "./db.js";
+import type { CockroachDialect } from "./dialect.js";
+import type { SelectedFieldsOrdered } from "./query-builders/select.types.js";
+export interface PreparedQueryConfig {
+    execute: unknown;
+    all: unknown;
+    values: unknown;
+}
+export declare abstract class CockroachPreparedQuery<T extends PreparedQueryConfig> implements PreparedQuery {
+    protected query: Query;
+    constructor(query: Query);
+    protected authToken?: NeonAuthToken;
+    getQuery(): Query;
+    mapResult(response: unknown, _isFromBatch?: boolean): unknown;
+    static readonly [entityKind]: string;
+    abstract execute(placeholderValues?: Record<string, unknown>): Promise<T['execute']>;
+}
+export interface CockroachTransactionConfig {
+    isolationLevel?: 'read uncommitted' | 'read committed' | 'repeatable read' | 'serializable';
+    accessMode?: 'read only' | 'read write';
+    deferrable?: boolean;
+}
+export declare abstract class CockroachSession<TQueryResult extends CockroachQueryResultHKT = CockroachQueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends V1.TablesRelationalConfig = Record<string, never>> {
+    protected dialect: CockroachDialect;
+    static readonly [entityKind]: string;
+    constructor(dialect: CockroachDialect);
+    abstract prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(query: Query, fields: SelectedFieldsOrdered | undefined, name: string | undefined, isResponseInArrayMode: boolean, customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => T['execute']): CockroachPreparedQuery<T>;
+    execute<T>(query: SQL): Promise<T>;
+    all<T = unknown>(query: SQL): Promise<T[]>;
+    count(sql: SQL): Promise<number>;
+    abstract transaction<T>(transaction: (tx: CockroachTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>, config?: CockroachTransactionConfig): Promise<T>;
+}
+export declare abstract class CockroachTransaction<TQueryResult extends CockroachQueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends V1.TablesRelationalConfig = Record<string, never>> extends CockroachDatabase<TQueryResult, TFullSchema, TSchema> {
+    protected schema: {
+        fullSchema: Record<string, unknown>;
+        schema: TSchema;
+        tableNamesMap: Record<string, string>;
+    } | undefined;
+    protected readonly nestedIndex: number;
+    static readonly [entityKind]: string;
+    constructor(dialect: CockroachDialect, session: CockroachSession<any, any, any>, schema: {
+        fullSchema: Record<string, unknown>;
+        schema: TSchema;
+        tableNamesMap: Record<string, string>;
+    } | undefined, nestedIndex?: number);
+    rollback(): never;
+    setTransaction(config: CockroachTransactionConfig): Promise<void>;
+    abstract transaction<T>(transaction: (tx: CockroachTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>): Promise<T>;
+}
+export interface CockroachQueryResultHKT {
+    readonly $brand: 'CockroachQueryResultHKT';
+    readonly row: unknown;
+    readonly type: unknown;
+}
+export type CockroachQueryResultKind<TKind extends CockroachQueryResultHKT, TRow> = (TKind & {
+    readonly row: TRow;
+})['type'];