@erfanium/drizzle-orm 1.0.0 → 1.0.1

package/durable-sqlite/session.d.cts

@@ -1,37 +1,33 @@
-import { entityKind } from "../entity.cjs";
-import { Query } from "../sql/sql.cjs";
-import { DrizzleTypeError } from "../utils.cjs";
-import { AnyRelations } from "../relations.cjs";
-import { Logger } from "../logger.cjs";
-import { SQLiteExecuteMethod, SQLiteTransactionConfig } from "../sqlite-core/session.cjs";
-import { SQLiteAsyncPreparedQuery, SQLiteAsyncPreparedQueryConfig, SQLiteAsyncSession, SQLiteAsyncTransaction } from "../sqlite-core/async/session.cjs";
-import { SQLiteDialect } from "../sqlite-core/index.cjs";
-
-//#region src/durable-sqlite/session.d.ts
-interface SQLiteDOSessionOptions {
-  logger?: Logger;
+import { entityKind } from '../entity.cjs';
+import type { Logger } from '../logger.cjs';
+import type { AnyRelations } from '../relations.cjs';
+import type { Query } from '../sql/sql.cjs';
+import { SQLiteAsyncPreparedQuery, type SQLiteAsyncPreparedQueryConfig as PreparedQueryConfigBase, SQLiteAsyncSession, SQLiteAsyncTransaction } from '../sqlite-core/async/session.cjs';
+import type { SQLiteDialect } from '../sqlite-core/index.cjs';
+import type { SQLiteExecuteMethod, SQLiteTransactionConfig } from '../sqlite-core/session.cjs';
+import type { DrizzleTypeError } from '../utils.cjs';
+export interface SQLiteDOSessionOptions {
+    logger?: Logger;
 }
-type PreparedQueryConfig$1 = Omit<SQLiteAsyncPreparedQueryConfig, 'statement' | 'run'>;
-type DurableSQLiteRunResult = SqlStorageCursor<Record<string, SqlStorageValue>>;
-declare class SQLiteDOSession<TRelations extends AnyRelations> extends SQLiteAsyncSession<'sync', DurableSQLiteRunResult, TRelations> {
-  private client;
-  private relations;
-  private options;
-  static readonly [entityKind]: string;
-  private logger;
-  constructor(client: DurableObjectStorage, dialect: SQLiteDialect, relations: TRelations, options?: SQLiteDOSessionOptions);
-  prepareQuery<T extends Omit<PreparedQueryConfig$1, 'run'>>(query: Query, mode: 'arrays' | 'objects' | 'raw', _prepare: boolean, executeMethod?: SQLiteExecuteMethod, mapper?: (rows: any[]) => any, queryMetadata?: {
-    type: 'select' | 'update' | 'delete' | 'insert';
-    tables: string[];
-  }): SQLiteAsyncPreparedQuery<T & {
-    run: DurableSQLiteRunResult;
-  }>;
-  transaction<T>(transaction: (tx: SQLiteAsyncTransaction<'sync', DurableSQLiteRunResult, TRelations>) => T, _config?: SQLiteTransactionConfig): T;
+type PreparedQueryConfig = Omit<PreparedQueryConfigBase, 'statement' | 'run'>;
+export type DurableSQLiteRunResult = SqlStorageCursor<Record<string, SqlStorageValue>>;
+export declare class SQLiteDOSession<TRelations extends AnyRelations> extends SQLiteAsyncSession<'sync', DurableSQLiteRunResult, TRelations> {
+    private client;
+    private relations;
+    private options;
+    static readonly [entityKind]: string;
+    private logger;
+    constructor(client: DurableObjectStorage, dialect: SQLiteDialect, relations: TRelations, options?: SQLiteDOSessionOptions);
+    prepareQuery<T extends Omit<PreparedQueryConfig, 'run'>>(query: Query, mode: 'arrays' | 'objects' | 'raw', _prepare: boolean, executeMethod?: SQLiteExecuteMethod, mapper?: (rows: any[]) => any, queryMetadata?: {
+        type: 'select' | 'update' | 'delete' | 'insert';
+        tables: string[];
+    }): SQLiteAsyncPreparedQuery<T & {
+        run: DurableSQLiteRunResult;
+    }>;
+    transaction<T>(transaction: (tx: SQLiteAsyncTransaction<'sync', DurableSQLiteRunResult, TRelations>) => T, _config?: SQLiteTransactionConfig): T;
 }
-declare class SQLiteDOTransaction<TRelations extends AnyRelations> extends SQLiteAsyncTransaction<'sync', DurableSQLiteRunResult, TRelations> {
-  static readonly [entityKind]: string;
-  transaction<T>(transaction: (tx: SQLiteDOTransaction<TRelations>) => T extends Promise<any> ? DrizzleTypeError<"Sync drivers can't use async functions in transactions!"> : T): T;
+export declare class SQLiteDOTransaction<TRelations extends AnyRelations> extends SQLiteAsyncTransaction<'sync', DurableSQLiteRunResult, TRelations> {
+    static readonly [entityKind]: string;
+    transaction<T>(transaction: (tx: SQLiteDOTransaction<TRelations>) => T extends Promise<any> ? DrizzleTypeError<"Sync drivers can't use async functions in transactions!"> : T): T;
 }
-//#endregion
-export { DurableSQLiteRunResult, SQLiteDOSession, SQLiteDOSessionOptions, SQLiteDOTransaction };
-//# sourceMappingURL=session.d.cts.map
+export {};

package/durable-sqlite/session.d.ts

@@ -1,37 +1,33 @@
-import { entityKind } from "../entity.js";
-import { DrizzleTypeError } from "../utils.js";
-import { Query } from "../sql/sql.js";
-import { Logger } from "../logger.js";
-import { AnyRelations } from "../relations.js";
-import { SQLiteAsyncPreparedQuery, SQLiteAsyncPreparedQueryConfig, SQLiteAsyncSession, SQLiteAsyncTransaction } from "../sqlite-core/async/session.js";
-import { SQLiteExecuteMethod, SQLiteTransactionConfig } from "../sqlite-core/session.js";
-import { SQLiteDialect } from "../sqlite-core/index.js";
-
-//#region src/durable-sqlite/session.d.ts
-interface SQLiteDOSessionOptions {
-  logger?: Logger;
+import { entityKind } from '../entity.js';
+import type { Logger } from '../logger.js';
+import type { AnyRelations } from '../relations.js';
+import type { Query } from '../sql/sql.js';
+import { SQLiteAsyncPreparedQuery, type SQLiteAsyncPreparedQueryConfig as PreparedQueryConfigBase, SQLiteAsyncSession, SQLiteAsyncTransaction } from '../sqlite-core/async/session.js';
+import type { SQLiteDialect } from '../sqlite-core/index.js';
+import type { SQLiteExecuteMethod, SQLiteTransactionConfig } from '../sqlite-core/session.js';
+import type { DrizzleTypeError } from '../utils.js';
+export interface SQLiteDOSessionOptions {
+    logger?: Logger;
 }
-type PreparedQueryConfig$1 = Omit<SQLiteAsyncPreparedQueryConfig, 'statement' | 'run'>;
-type DurableSQLiteRunResult = SqlStorageCursor<Record<string, SqlStorageValue>>;
-declare class SQLiteDOSession<TRelations extends AnyRelations> extends SQLiteAsyncSession<'sync', DurableSQLiteRunResult, TRelations> {
-  private client;
-  private relations;
-  private options;
-  static readonly [entityKind]: string;
-  private logger;
-  constructor(client: DurableObjectStorage, dialect: SQLiteDialect, relations: TRelations, options?: SQLiteDOSessionOptions);
-  prepareQuery<T extends Omit<PreparedQueryConfig$1, 'run'>>(query: Query, mode: 'arrays' | 'objects' | 'raw', _prepare: boolean, executeMethod?: SQLiteExecuteMethod, mapper?: (rows: any[]) => any, queryMetadata?: {
-    type: 'select' | 'update' | 'delete' | 'insert';
-    tables: string[];
-  }): SQLiteAsyncPreparedQuery<T & {
-    run: DurableSQLiteRunResult;
-  }>;
-  transaction<T>(transaction: (tx: SQLiteAsyncTransaction<'sync', DurableSQLiteRunResult, TRelations>) => T, _config?: SQLiteTransactionConfig): T;
+type PreparedQueryConfig = Omit<PreparedQueryConfigBase, 'statement' | 'run'>;
+export type DurableSQLiteRunResult = SqlStorageCursor<Record<string, SqlStorageValue>>;
+export declare class SQLiteDOSession<TRelations extends AnyRelations> extends SQLiteAsyncSession<'sync', DurableSQLiteRunResult, TRelations> {
+    private client;
+    private relations;
+    private options;
+    static readonly [entityKind]: string;
+    private logger;
+    constructor(client: DurableObjectStorage, dialect: SQLiteDialect, relations: TRelations, options?: SQLiteDOSessionOptions);
+    prepareQuery<T extends Omit<PreparedQueryConfig, 'run'>>(query: Query, mode: 'arrays' | 'objects' | 'raw', _prepare: boolean, executeMethod?: SQLiteExecuteMethod, mapper?: (rows: any[]) => any, queryMetadata?: {
+        type: 'select' | 'update' | 'delete' | 'insert';
+        tables: string[];
+    }): SQLiteAsyncPreparedQuery<T & {
+        run: DurableSQLiteRunResult;
+    }>;
+    transaction<T>(transaction: (tx: SQLiteAsyncTransaction<'sync', DurableSQLiteRunResult, TRelations>) => T, _config?: SQLiteTransactionConfig): T;
 }
-declare class SQLiteDOTransaction<TRelations extends AnyRelations> extends SQLiteAsyncTransaction<'sync', DurableSQLiteRunResult, TRelations> {
-  static readonly [entityKind]: string;
-  transaction<T>(transaction: (tx: SQLiteDOTransaction<TRelations>) => T extends Promise<any> ? DrizzleTypeError<"Sync drivers can't use async functions in transactions!"> : T): T;
+export declare class SQLiteDOTransaction<TRelations extends AnyRelations> extends SQLiteAsyncTransaction<'sync', DurableSQLiteRunResult, TRelations> {
+    static readonly [entityKind]: string;
+    transaction<T>(transaction: (tx: SQLiteDOTransaction<TRelations>) => T extends Promise<any> ? DrizzleTypeError<"Sync drivers can't use async functions in transactions!"> : T): T;
 }
-//#endregion
-export { DurableSQLiteRunResult, SQLiteDOSession, SQLiteDOSessionOptions, SQLiteDOTransaction };
-//# sourceMappingURL=session.d.ts.map
+export {};

package/effect-core/defaults.cjs

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
 const require_effect_core_logger = require('./logger.cjs');
-let __cache_core_cache_effect_ts = require("../cache/core/cache-effect.cjs");
 let effect = require("effect");
+let __cache_core_cache_effect_ts = require("../cache/core/cache-effect.cjs");
 
 //#region src/effect-core/defaults.ts
 const DefaultServices = effect.Layer.merge(__cache_core_cache_effect_ts.EffectCache.Default, require_effect_core_logger.EffectLogger.Default);

package/effect-core/defaults.d.cts

@@ -1,9 +1,4 @@
-import { EffectLogger } from "./logger.cjs";
-import { Layer } from "effect";
-import { EffectCache } from "../cache/core/cache-effect.cjs";
-
-//#region src/effect-core/defaults.d.ts
-declare const DefaultServices: Layer.Layer<EffectLogger | EffectCache, never, never>;
-//#endregion
-export { DefaultServices };
-//# sourceMappingURL=defaults.d.cts.map
+import { Layer } from 'effect';
+import { EffectCache } from '../cache/core/cache-effect.cjs';
+import { EffectLogger } from './logger.cjs';
+export declare const DefaultServices: Layer.Layer<EffectCache | EffectLogger, never, never>;

package/effect-core/defaults.d.ts

@@ -1,9 +1,4 @@
-import { EffectLogger } from "./logger.js";
-import { EffectCache } from "../cache/core/cache-effect.js";
-import { Layer } from "effect";
-
-//#region src/effect-core/defaults.d.ts
-declare const DefaultServices: Layer.Layer<EffectLogger | EffectCache, never, never>;
-//#endregion
-export { DefaultServices };
-//# sourceMappingURL=defaults.d.ts.map
+import { Layer } from 'effect';
+import { EffectCache } from '../cache/core/cache-effect.js';
+import { EffectLogger } from './logger.js';
+export declare const DefaultServices: Layer.Layer<EffectCache | EffectLogger, never, never>;

package/effect-core/defaults.js

@@ -1,6 +1,6 @@
 import { EffectLogger } from "./logger.js";
-import { EffectCache } from "../cache/core/cache-effect.js";
 import { Layer } from "effect";
+import { EffectCache } from "../cache/core/cache-effect.js";
 
 //#region src/effect-core/defaults.ts
 const DefaultServices = Layer.merge(EffectCache.Default, EffectLogger.Default);

package/effect-core/errors.cjs

@@ -1,6 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
 let __entity_ts = require("../entity.cjs");
+let __errors_ts = require("../errors.cjs");
 let effect_Schema = require("effect/Schema");
 effect_Schema = require_runtime.__toESM(effect_Schema);
 
@@ -18,7 +19,7 @@ var EffectDrizzleQueryError = class EffectDrizzleQueryError extends effect_Schem
 }) {
 	static [__entity_ts.entityKind] = "EffectDrizzleQueryError";
 	get message() {
-		return `Failed query: ${this.query}\nparams: ${this.params}`;
+		return `Failed query: ${this.query}\nparams: ${(0, __errors_ts.formatQueryParams)(this.params)}`;
 	}
 	constructor(params) {
 		super(params);

package/effect-core/errors.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"errors.cjs","names":["Schema","entityKind"],"sources":["../../src/effect-core/errors.ts"],"sourcesContent":["import * as Schema from 'effect/Schema';\nimport { entityKind } from '~/entity.ts';\n\nexport class EffectDrizzleError extends Schema.TaggedErrorClass<EffectDrizzleError>()('EffectDrizzleError', {\n\tmessage: Schema.String,\n\tcause: Schema.Unknown,\n}) {\n\tstatic readonly [entityKind]: string = 'EffectDrizzleError';\n}\n\nexport class EffectDrizzleQueryError\n\textends Schema.TaggedErrorClass<EffectDrizzleQueryError>()('EffectDrizzleQueryError', {\n\t\tquery: Schema.String,\n\t\tparams: Schema.Array(Schema.Any).pipe(Schema.mutable),\n\t\tcause: Schema.Unknown,\n\t})\n{\n\tstatic readonly [entityKind]: string = 'EffectDrizzleQueryError';\n\n\toverride get message() {\n\t\treturn `Failed query: ${this.query}\\nparams: ${this.params}`;\n\t}\n\n\tconstructor(params: Omit<Schema.Struct.MakeIn<typeof EffectDrizzleQueryError.fields>, '_tag'>) {\n\t\tsuper(params);\n\t\tError.captureStackTrace(this, EffectDrizzleQueryError);\n\t}\n}\n\nexport class EffectTransactionRollbackError\n\textends Schema.TaggedErrorClass<EffectTransactionRollbackError>()('EffectTransactionRollbackError', {})\n{\n\tstatic readonly [entityKind]: string = 'EffectTransactionRollbackError';\n\n\toverride readonly message = 'Rollback';\n}\n\nexport class MigratorInitError extends Schema.TaggedErrorClass<MigratorInitError>()('MigratorInitError', {\n\texitCode: Schema.Literals(['databaseMigrations', 'localMigrations']),\n}) {\n\tstatic readonly [entityKind]: string = 'MigratorInitError';\n}\n"],"mappings":";;;;;;;AAGA,IAAa,qBAAb,cAAwCA,cAAO,kBAAsC,CAAC,sBAAsB;CAC3G,SAASA,cAAO;CAChB,OAAOA,cAAO;CACd,CAAC,CAAC;CACF,QAAiBC,0BAAsB;;AAGxC,IAAa,0BAAb,MAAa,gCACJD,cAAO,kBAA2C,CAAC,2BAA2B;CACrF,OAAOA,cAAO;CACd,QAAQA,cAAO,MAAMA,cAAO,IAAI,CAAC,KAAKA,cAAO,QAAQ;CACrD,OAAOA,cAAO;CACd,CAAC,CACH;CACC,QAAiBC,0BAAsB;CAEvC,IAAa,UAAU;AACtB,SAAO,iBAAiB,KAAK,MAAM,YAAY,KAAK;;CAGrD,YAAY,QAAmF;AAC9F,QAAM,OAAO;AACb,QAAM,kBAAkB,MAAM,wBAAwB;;;AAIxD,IAAa,iCAAb,cACSD,cAAO,kBAAkD,CAAC,kCAAkC,EAAE,CAAC,CACxG;CACC,QAAiBC,0BAAsB;CAEvC,AAAkB,UAAU;;AAG7B,IAAa,oBAAb,cAAuCD,cAAO,kBAAqC,CAAC,qBAAqB,EACxG,UAAUA,cAAO,SAAS,CAAC,sBAAsB,kBAAkB,CAAC,EACpE,CAAC,CAAC;CACF,QAAiBC,0BAAsB"}
+{"version":3,"file":"errors.cjs","names":["Schema","entityKind"],"sources":["../../src/effect-core/errors.ts"],"sourcesContent":["import * as Schema from 'effect/Schema';\nimport { entityKind } from '~/entity.ts';\nimport { formatQueryParams } from '~/errors.ts';\n\nexport class EffectDrizzleError extends Schema.TaggedErrorClass<EffectDrizzleError>()('EffectDrizzleError', {\n\tmessage: Schema.String,\n\tcause: Schema.Unknown,\n}) {\n\tstatic readonly [entityKind]: string = 'EffectDrizzleError';\n}\n\nexport class EffectDrizzleQueryError\n\textends Schema.TaggedErrorClass<EffectDrizzleQueryError>()('EffectDrizzleQueryError', {\n\t\tquery: Schema.String,\n\t\tparams: Schema.Array(Schema.Any).pipe(Schema.mutable),\n\t\tcause: Schema.Unknown,\n\t})\n{\n\tstatic readonly [entityKind]: string = 'EffectDrizzleQueryError';\n\n\toverride get message() {\n\t\treturn `Failed query: ${this.query}\\nparams: ${formatQueryParams(this.params)}`;\n\t}\n\n\tconstructor(params: Omit<Schema.Struct.MakeIn<typeof EffectDrizzleQueryError.fields>, '_tag'>) {\n\t\tsuper(params);\n\t\tError.captureStackTrace(this, EffectDrizzleQueryError);\n\t}\n}\n\nexport class EffectTransactionRollbackError\n\textends Schema.TaggedErrorClass<EffectTransactionRollbackError>()('EffectTransactionRollbackError', {})\n{\n\tstatic readonly [entityKind]: string = 'EffectTransactionRollbackError';\n\n\toverride readonly message = 'Rollback';\n}\n\nexport class MigratorInitError extends Schema.TaggedErrorClass<MigratorInitError>()('MigratorInitError', {\n\texitCode: Schema.Literals(['databaseMigrations', 'localMigrations']),\n}) {\n\tstatic readonly [entityKind]: string = 'MigratorInitError';\n}\n"],"mappings":";;;;;;;;AAIA,IAAa,qBAAb,cAAwCA,cAAO,kBAAsC,CAAC,sBAAsB;CAC3G,SAASA,cAAO;CAChB,OAAOA,cAAO;CACd,CAAC,CAAC;CACF,QAAiBC,0BAAsB;;AAGxC,IAAa,0BAAb,MAAa,gCACJD,cAAO,kBAA2C,CAAC,2BAA2B;CACrF,OAAOA,cAAO;CACd,QAAQA,cAAO,MAAMA,cAAO,IAAI,CAAC,KAAKA,cAAO,QAAQ;CACrD,OAAOA,cAAO;CACd,CAAC,CACH;CACC,QAAiBC,0BAAsB;CAEvC,IAAa,UAAU;AACtB,SAAO,iBAAiB,KAAK,MAAM,+CAA8B,KAAK,OAAO;;CAG9E,YAAY,QAAmF;AAC9F,QAAM,OAAO;AACb,QAAM,kBAAkB,MAAM,wBAAwB;;;AAIxD,IAAa,iCAAb,cACSD,cAAO,kBAAkD,CAAC,kCAAkC,EAAE,CAAC,CACxG;CACC,QAAiBC,0BAAsB;CAEvC,AAAkB,UAAU;;AAG7B,IAAa,oBAAb,cAAuCD,cAAO,kBAAqC,CAAC,qBAAqB,EACxG,UAAUA,cAAO,SAAS,CAAC,sBAAsB,kBAAkB,CAAC,EACpE,CAAC,CAAC;CACF,QAAiBC,0BAAsB"}

package/effect-core/errors.d.cts

@@ -1,36 +1,31 @@
-import { entityKind } from "../entity.cjs";
-import * as effect_Cause0 from "effect/Cause";
-import * as Schema$1 from "effect/Schema";
-
-//#region src/effect-core/errors.d.ts
-declare const EffectDrizzleError_base: Schema$1.Class<EffectDrizzleError, Schema$1.TaggedStruct<"EffectDrizzleError", {
-  readonly message: Schema$1.String;
-  readonly cause: Schema$1.Unknown;
-}>, effect_Cause0.YieldableError>;
-declare class EffectDrizzleError extends EffectDrizzleError_base {
-  static readonly [entityKind]: string;
+import * as Schema from 'effect/Schema';
+import { entityKind } from '../entity.cjs';
+declare const EffectDrizzleError_base: Schema.Class<EffectDrizzleError, Schema.TaggedStruct<"EffectDrizzleError", {
+    readonly message: Schema.String;
+    readonly cause: Schema.Unknown;
+}>, import("effect/Cause").YieldableError>;
+export declare class EffectDrizzleError extends EffectDrizzleError_base {
+    static readonly [entityKind]: string;
 }
-declare const EffectDrizzleQueryError_base: Schema$1.Class<EffectDrizzleQueryError, Schema$1.TaggedStruct<"EffectDrizzleQueryError", {
-  readonly query: Schema$1.String;
-  readonly params: Schema$1.mutable<Schema$1.$Array<Schema$1.Any>>;
-  readonly cause: Schema$1.Unknown;
-}>, effect_Cause0.YieldableError>;
-declare class EffectDrizzleQueryError extends EffectDrizzleQueryError_base {
-  static readonly [entityKind]: string;
-  get message(): string;
-  constructor(params: Omit<Schema$1.Struct.MakeIn<typeof EffectDrizzleQueryError.fields>, '_tag'>);
+declare const EffectDrizzleQueryError_base: Schema.Class<EffectDrizzleQueryError, Schema.TaggedStruct<"EffectDrizzleQueryError", {
+    readonly query: Schema.String;
+    readonly params: Schema.mutable<Schema.$Array<Schema.Any>>;
+    readonly cause: Schema.Unknown;
+}>, import("effect/Cause").YieldableError>;
+export declare class EffectDrizzleQueryError extends EffectDrizzleQueryError_base {
+    static readonly [entityKind]: string;
+    get message(): string;
+    constructor(params: Omit<Schema.Struct.MakeIn<typeof EffectDrizzleQueryError.fields>, '_tag'>);
 }
-declare const EffectTransactionRollbackError_base: Schema$1.Class<EffectTransactionRollbackError, Schema$1.TaggedStruct<"EffectTransactionRollbackError", {}>, effect_Cause0.YieldableError>;
-declare class EffectTransactionRollbackError extends EffectTransactionRollbackError_base {
-  static readonly [entityKind]: string;
-  readonly message = "Rollback";
+declare const EffectTransactionRollbackError_base: Schema.Class<EffectTransactionRollbackError, Schema.TaggedStruct<"EffectTransactionRollbackError", {}>, import("effect/Cause").YieldableError>;
+export declare class EffectTransactionRollbackError extends EffectTransactionRollbackError_base {
+    static readonly [entityKind]: string;
+    readonly message = "Rollback";
 }
-declare const MigratorInitError_base: Schema$1.Class<MigratorInitError, Schema$1.TaggedStruct<"MigratorInitError", {
-  readonly exitCode: Schema$1.Literals<readonly ["databaseMigrations", "localMigrations"]>;
-}>, effect_Cause0.YieldableError>;
-declare class MigratorInitError extends MigratorInitError_base {
-  static readonly [entityKind]: string;
+declare const MigratorInitError_base: Schema.Class<MigratorInitError, Schema.TaggedStruct<"MigratorInitError", {
+    readonly exitCode: Schema.Literals<readonly ["databaseMigrations", "localMigrations"]>;
+}>, import("effect/Cause").YieldableError>;
+export declare class MigratorInitError extends MigratorInitError_base {
+    static readonly [entityKind]: string;
 }
-//#endregion
-export { EffectDrizzleError, EffectDrizzleQueryError, EffectTransactionRollbackError, MigratorInitError };
-//# sourceMappingURL=errors.d.cts.map
+export {};

package/effect-core/errors.d.ts

@@ -1,36 +1,31 @@
-import { entityKind } from "../entity.js";
-import * as Schema$1 from "effect/Schema";
-import * as effect_Cause0 from "effect/Cause";
-
-//#region src/effect-core/errors.d.ts
-declare const EffectDrizzleError_base: Schema$1.Class<EffectDrizzleError, Schema$1.TaggedStruct<"EffectDrizzleError", {
-  readonly message: Schema$1.String;
-  readonly cause: Schema$1.Unknown;
-}>, effect_Cause0.YieldableError>;
-declare class EffectDrizzleError extends EffectDrizzleError_base {
-  static readonly [entityKind]: string;
+import * as Schema from 'effect/Schema';
+import { entityKind } from '../entity.js';
+declare const EffectDrizzleError_base: Schema.Class<EffectDrizzleError, Schema.TaggedStruct<"EffectDrizzleError", {
+    readonly message: Schema.String;
+    readonly cause: Schema.Unknown;
+}>, import("effect/Cause").YieldableError>;
+export declare class EffectDrizzleError extends EffectDrizzleError_base {
+    static readonly [entityKind]: string;
 }
-declare const EffectDrizzleQueryError_base: Schema$1.Class<EffectDrizzleQueryError, Schema$1.TaggedStruct<"EffectDrizzleQueryError", {
-  readonly query: Schema$1.String;
-  readonly params: Schema$1.mutable<Schema$1.$Array<Schema$1.Any>>;
-  readonly cause: Schema$1.Unknown;
-}>, effect_Cause0.YieldableError>;
-declare class EffectDrizzleQueryError extends EffectDrizzleQueryError_base {
-  static readonly [entityKind]: string;
-  get message(): string;
-  constructor(params: Omit<Schema$1.Struct.MakeIn<typeof EffectDrizzleQueryError.fields>, '_tag'>);
+declare const EffectDrizzleQueryError_base: Schema.Class<EffectDrizzleQueryError, Schema.TaggedStruct<"EffectDrizzleQueryError", {
+    readonly query: Schema.String;
+    readonly params: Schema.mutable<Schema.$Array<Schema.Any>>;
+    readonly cause: Schema.Unknown;
+}>, import("effect/Cause").YieldableError>;
+export declare class EffectDrizzleQueryError extends EffectDrizzleQueryError_base {
+    static readonly [entityKind]: string;
+    get message(): string;
+    constructor(params: Omit<Schema.Struct.MakeIn<typeof EffectDrizzleQueryError.fields>, '_tag'>);
 }
-declare const EffectTransactionRollbackError_base: Schema$1.Class<EffectTransactionRollbackError, Schema$1.TaggedStruct<"EffectTransactionRollbackError", {}>, effect_Cause0.YieldableError>;
-declare class EffectTransactionRollbackError extends EffectTransactionRollbackError_base {
-  static readonly [entityKind]: string;
-  readonly message = "Rollback";
+declare const EffectTransactionRollbackError_base: Schema.Class<EffectTransactionRollbackError, Schema.TaggedStruct<"EffectTransactionRollbackError", {}>, import("effect/Cause").YieldableError>;
+export declare class EffectTransactionRollbackError extends EffectTransactionRollbackError_base {
+    static readonly [entityKind]: string;
+    readonly message = "Rollback";
 }
-declare const MigratorInitError_base: Schema$1.Class<MigratorInitError, Schema$1.TaggedStruct<"MigratorInitError", {
-  readonly exitCode: Schema$1.Literals<readonly ["databaseMigrations", "localMigrations"]>;
-}>, effect_Cause0.YieldableError>;
-declare class MigratorInitError extends MigratorInitError_base {
-  static readonly [entityKind]: string;
+declare const MigratorInitError_base: Schema.Class<MigratorInitError, Schema.TaggedStruct<"MigratorInitError", {
+    readonly exitCode: Schema.Literals<readonly ["databaseMigrations", "localMigrations"]>;
+}>, import("effect/Cause").YieldableError>;
+export declare class MigratorInitError extends MigratorInitError_base {
+    static readonly [entityKind]: string;
 }
-//#endregion
-export { EffectDrizzleError, EffectDrizzleQueryError, EffectTransactionRollbackError, MigratorInitError };
-//# sourceMappingURL=errors.d.ts.map
+export {};

package/effect-core/errors.js

@@ -1,32 +1,33 @@
 import { entityKind } from "../entity.js";
-import * as Schema$1 from "effect/Schema";
+import { formatQueryParams } from "../errors.js";
+import * as Schema from "effect/Schema";
 
 //#region src/effect-core/errors.ts
-var EffectDrizzleError = class extends Schema$1.TaggedErrorClass()("EffectDrizzleError", {
-	message: Schema$1.String,
-	cause: Schema$1.Unknown
+var EffectDrizzleError = class extends Schema.TaggedErrorClass()("EffectDrizzleError", {
+	message: Schema.String,
+	cause: Schema.Unknown
 }) {
 	static [entityKind] = "EffectDrizzleError";
 };
-var EffectDrizzleQueryError = class EffectDrizzleQueryError extends Schema$1.TaggedErrorClass()("EffectDrizzleQueryError", {
-	query: Schema$1.String,
-	params: Schema$1.Array(Schema$1.Any).pipe(Schema$1.mutable),
-	cause: Schema$1.Unknown
+var EffectDrizzleQueryError = class EffectDrizzleQueryError extends Schema.TaggedErrorClass()("EffectDrizzleQueryError", {
+	query: Schema.String,
+	params: Schema.Array(Schema.Any).pipe(Schema.mutable),
+	cause: Schema.Unknown
 }) {
 	static [entityKind] = "EffectDrizzleQueryError";
 	get message() {
-		return `Failed query: ${this.query}\nparams: ${this.params}`;
+		return `Failed query: ${this.query}\nparams: ${formatQueryParams(this.params)}`;
 	}
 	constructor(params) {
 		super(params);
 		Error.captureStackTrace(this, EffectDrizzleQueryError);
 	}
 };
-var EffectTransactionRollbackError = class extends Schema$1.TaggedErrorClass()("EffectTransactionRollbackError", {}) {
+var EffectTransactionRollbackError = class extends Schema.TaggedErrorClass()("EffectTransactionRollbackError", {}) {
 	static [entityKind] = "EffectTransactionRollbackError";
 	message = "Rollback";
 };
-var MigratorInitError = class extends Schema$1.TaggedErrorClass()("MigratorInitError", { exitCode: Schema$1.Literals(["databaseMigrations", "localMigrations"]) }) {
+var MigratorInitError = class extends Schema.TaggedErrorClass()("MigratorInitError", { exitCode: Schema.Literals(["databaseMigrations", "localMigrations"]) }) {
 	static [entityKind] = "MigratorInitError";
 };
 

package/effect-core/errors.js.map

@@ -1 +1 @@
-{"version":3,"file":"errors.js","names":["Schema"],"sources":["../../src/effect-core/errors.ts"],"sourcesContent":["import * as Schema from 'effect/Schema';\nimport { entityKind } from '~/entity.ts';\n\nexport class EffectDrizzleError extends Schema.TaggedErrorClass<EffectDrizzleError>()('EffectDrizzleError', {\n\tmessage: Schema.String,\n\tcause: Schema.Unknown,\n}) {\n\tstatic readonly [entityKind]: string = 'EffectDrizzleError';\n}\n\nexport class EffectDrizzleQueryError\n\textends Schema.TaggedErrorClass<EffectDrizzleQueryError>()('EffectDrizzleQueryError', {\n\t\tquery: Schema.String,\n\t\tparams: Schema.Array(Schema.Any).pipe(Schema.mutable),\n\t\tcause: Schema.Unknown,\n\t})\n{\n\tstatic readonly [entityKind]: string = 'EffectDrizzleQueryError';\n\n\toverride get message() {\n\t\treturn `Failed query: ${this.query}\\nparams: ${this.params}`;\n\t}\n\n\tconstructor(params: Omit<Schema.Struct.MakeIn<typeof EffectDrizzleQueryError.fields>, '_tag'>) {\n\t\tsuper(params);\n\t\tError.captureStackTrace(this, EffectDrizzleQueryError);\n\t}\n}\n\nexport class EffectTransactionRollbackError\n\textends Schema.TaggedErrorClass<EffectTransactionRollbackError>()('EffectTransactionRollbackError', {})\n{\n\tstatic readonly [entityKind]: string = 'EffectTransactionRollbackError';\n\n\toverride readonly message = 'Rollback';\n}\n\nexport class MigratorInitError extends Schema.TaggedErrorClass<MigratorInitError>()('MigratorInitError', {\n\texitCode: Schema.Literals(['databaseMigrations', 'localMigrations']),\n}) {\n\tstatic readonly [entityKind]: string = 'MigratorInitError';\n}\n"],"mappings":";;;;AAGA,IAAa,qBAAb,cAAwCA,SAAO,kBAAsC,CAAC,sBAAsB;CAC3G,SAASA,SAAO;CAChB,OAAOA,SAAO;CACd,CAAC,CAAC;CACF,QAAiB,cAAsB;;AAGxC,IAAa,0BAAb,MAAa,gCACJA,SAAO,kBAA2C,CAAC,2BAA2B;CACrF,OAAOA,SAAO;CACd,QAAQA,SAAO,MAAMA,SAAO,IAAI,CAAC,KAAKA,SAAO,QAAQ;CACrD,OAAOA,SAAO;CACd,CAAC,CACH;CACC,QAAiB,cAAsB;CAEvC,IAAa,UAAU;AACtB,SAAO,iBAAiB,KAAK,MAAM,YAAY,KAAK;;CAGrD,YAAY,QAAmF;AAC9F,QAAM,OAAO;AACb,QAAM,kBAAkB,MAAM,wBAAwB;;;AAIxD,IAAa,iCAAb,cACSA,SAAO,kBAAkD,CAAC,kCAAkC,EAAE,CAAC,CACxG;CACC,QAAiB,cAAsB;CAEvC,AAAkB,UAAU;;AAG7B,IAAa,oBAAb,cAAuCA,SAAO,kBAAqC,CAAC,qBAAqB,EACxG,UAAUA,SAAO,SAAS,CAAC,sBAAsB,kBAAkB,CAAC,EACpE,CAAC,CAAC;CACF,QAAiB,cAAsB"}
+{"version":3,"file":"errors.js","names":[],"sources":["../../src/effect-core/errors.ts"],"sourcesContent":["import * as Schema from 'effect/Schema';\nimport { entityKind } from '~/entity.ts';\nimport { formatQueryParams } from '~/errors.ts';\n\nexport class EffectDrizzleError extends Schema.TaggedErrorClass<EffectDrizzleError>()('EffectDrizzleError', {\n\tmessage: Schema.String,\n\tcause: Schema.Unknown,\n}) {\n\tstatic readonly [entityKind]: string = 'EffectDrizzleError';\n}\n\nexport class EffectDrizzleQueryError\n\textends Schema.TaggedErrorClass<EffectDrizzleQueryError>()('EffectDrizzleQueryError', {\n\t\tquery: Schema.String,\n\t\tparams: Schema.Array(Schema.Any).pipe(Schema.mutable),\n\t\tcause: Schema.Unknown,\n\t})\n{\n\tstatic readonly [entityKind]: string = 'EffectDrizzleQueryError';\n\n\toverride get message() {\n\t\treturn `Failed query: ${this.query}\\nparams: ${formatQueryParams(this.params)}`;\n\t}\n\n\tconstructor(params: Omit<Schema.Struct.MakeIn<typeof EffectDrizzleQueryError.fields>, '_tag'>) {\n\t\tsuper(params);\n\t\tError.captureStackTrace(this, EffectDrizzleQueryError);\n\t}\n}\n\nexport class EffectTransactionRollbackError\n\textends Schema.TaggedErrorClass<EffectTransactionRollbackError>()('EffectTransactionRollbackError', {})\n{\n\tstatic readonly [entityKind]: string = 'EffectTransactionRollbackError';\n\n\toverride readonly message = 'Rollback';\n}\n\nexport class MigratorInitError extends Schema.TaggedErrorClass<MigratorInitError>()('MigratorInitError', {\n\texitCode: Schema.Literals(['databaseMigrations', 'localMigrations']),\n}) {\n\tstatic readonly [entityKind]: string = 'MigratorInitError';\n}\n"],"mappings":";;;;;AAIA,IAAa,qBAAb,cAAwC,OAAO,kBAAsC,CAAC,sBAAsB;CAC3G,SAAS,OAAO;CAChB,OAAO,OAAO;CACd,CAAC,CAAC;CACF,QAAiB,cAAsB;;AAGxC,IAAa,0BAAb,MAAa,gCACJ,OAAO,kBAA2C,CAAC,2BAA2B;CACrF,OAAO,OAAO;CACd,QAAQ,OAAO,MAAM,OAAO,IAAI,CAAC,KAAK,OAAO,QAAQ;CACrD,OAAO,OAAO;CACd,CAAC,CACH;CACC,QAAiB,cAAsB;CAEvC,IAAa,UAAU;AACtB,SAAO,iBAAiB,KAAK,MAAM,YAAY,kBAAkB,KAAK,OAAO;;CAG9E,YAAY,QAAmF;AAC9F,QAAM,OAAO;AACb,QAAM,kBAAkB,MAAM,wBAAwB;;;AAIxD,IAAa,iCAAb,cACS,OAAO,kBAAkD,CAAC,kCAAkC,EAAE,CAAC,CACxG;CACC,QAAiB,cAAsB;CAEvC,AAAkB,UAAU;;AAG7B,IAAa,oBAAb,cAAuC,OAAO,kBAAqC,CAAC,qBAAqB,EACxG,UAAU,OAAO,SAAS,CAAC,sBAAsB,kBAAkB,CAAC,EACpE,CAAC,CAAC;CACF,QAAiB,cAAsB"}

package/effect-core/index.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_effect_core_errors = require('./errors.cjs');
-const require_effect_core_logger = require('./logger.cjs');
 const require_effect_core_query_effect = require('./query-effect.cjs');
+const require_effect_core_logger = require('./logger.cjs');
+const require_effect_core_errors = require('./errors.cjs');
 
 exports.EffectDrizzleError = require_effect_core_errors.EffectDrizzleError;
 exports.EffectDrizzleQueryError = require_effect_core_errors.EffectDrizzleQueryError;

package/effect-core/index.d.cts

@@ -1,4 +1,3 @@
-import { EffectLogger, EffectLoggerShape } from "./logger.cjs";
-import { EffectDrizzleError, EffectDrizzleQueryError, EffectTransactionRollbackError, MigratorInitError } from "./errors.cjs";
-import { QueryEffectHKTBase, QueryEffectKind, applyEffectWrapper } from "./query-effect.cjs";
-export { EffectDrizzleError, EffectDrizzleQueryError, EffectLogger, EffectLoggerShape, EffectTransactionRollbackError, MigratorInitError, QueryEffectHKTBase, QueryEffectKind, applyEffectWrapper };
+export * from './errors.cjs';
+export * from './logger.cjs';
+export * from './query-effect.cjs';

package/effect-core/index.d.ts

@@ -1,4 +1,3 @@
-import { EffectLogger, EffectLoggerShape } from "./logger.js";
-import { EffectDrizzleError, EffectDrizzleQueryError, EffectTransactionRollbackError, MigratorInitError } from "./errors.js";
-import { QueryEffectHKTBase, QueryEffectKind, applyEffectWrapper } from "./query-effect.js";
-export { EffectDrizzleError, EffectDrizzleQueryError, EffectLogger, EffectLoggerShape, EffectTransactionRollbackError, MigratorInitError, QueryEffectHKTBase, QueryEffectKind, applyEffectWrapper };
+export * from './errors.js';
+export * from './logger.js';
+export * from './query-effect.js';

package/effect-core/index.js

@@ -1,5 +1,5 @@
-import { EffectDrizzleError, EffectDrizzleQueryError, EffectTransactionRollbackError, MigratorInitError } from "./errors.js";
-import { EffectLogger } from "./logger.js";
 import { applyEffectWrapper } from "./query-effect.js";
+import { EffectLogger } from "./logger.js";
+import { EffectDrizzleError, EffectDrizzleQueryError, EffectTransactionRollbackError, MigratorInitError } from "./errors.js";
 
 export { EffectDrizzleError, EffectDrizzleQueryError, EffectLogger, EffectTransactionRollbackError, MigratorInitError, applyEffectWrapper };

package/effect-core/logger.d.cts

@@ -1,15 +1,13 @@
-import { entityKind } from "../entity.cjs";
-import { Logger } from "../logger.cjs";
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-
-//#region src/effect-core/logger.d.ts
-interface EffectLoggerShape {
-  readonly logQuery: (query: string, params: unknown[]) => Effect.Effect<void, never, never>;
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import { entityKind } from '../entity.cjs';
+import type { Logger } from '../logger.cjs';
+export interface EffectLoggerShape {
+    readonly logQuery: (query: string, params: unknown[]) => Effect.Effect<void, never, never>;
 }
 declare const EffectLogger_base: Context.ServiceClass<EffectLogger, "drizzle-orm/EffectLogger", EffectLoggerShape> & {
-  readonly make: Effect.Effect<EffectLoggerShape, never, never>;
+    readonly make: Effect.Effect<EffectLoggerShape, never, never>;
 };
 /**
  * Effect service for logging SQL queries in Drizzle ORM.
@@ -38,58 +36,56 @@ declare const EffectLogger_base: Context.ServiceClass<EffectLogger, "drizzle-orm
  * );
  * ```
  */
-declare class EffectLogger extends EffectLogger_base {
-  static readonly [entityKind]: string;
-  /**
-   * The default layer providing a no-op logger.
-   */
-  static readonly Default: Layer.Layer<EffectLogger, never, never>;
-  /**
-   * Creates an EffectLoggerShape from a standard Drizzle logger.
-   *
-   * @param logger - A Drizzle logger instance implementing the `Logger` interface.
-   * @returns A new EffectLoggerShape that delegates to the provided Drizzle logger.
-   *
-   * @example
-   * ```ts
-   * const drizzleLogger = new DefaultLogger();
-   * const effectLogger = EffectLogger.fromDrizzle(drizzleLogger);
-   * ```
-   */
-  static fromDrizzle(logger: Logger): EffectLoggerShape;
-  /**
-   * Creates a Layer that provides an EffectLogger from a standard Drizzle logger.
-   *
-   * @param logger - A Drizzle logger instance implementing the `Logger` interface.
-   * @returns A Layer that provides the EffectLogger service.
-   *
-   * @example
-   * ```ts
-   * const drizzleLogger = new DefaultLogger();
-   * const db = yield* PgDrizzle.make({ relations }).pipe(
-   *   Effect.provide(EffectLogger.layerFromDrizzle(drizzleLogger)),
-   *   Effect.provide(PgDrizzle.DefaultServices),
-   * );
-   * ```
-   */
-  static layerFromDrizzle(logger: Logger): Layer.Layer<EffectLogger, never, never>;
-  /**
-   * A Layer that provides an EffectLogger with Effect-based logging.
-   *
-   * This layer logs queries using `Effect.log()` with annotations for the query
-   * SQL and parameters. Use this when you want query logging integrated with
-   * Effect's logging infrastructure.
-   *
-   * @example
-   * ```ts
-   * const db = yield* PgDrizzle.make({ relations }).pipe(
-   *   Effect.provide(EffectLogger.layer),
-   *   Effect.provide(PgDrizzle.DefaultServices),
-   * );
-   * ```
-   */
-  static layer: Layer.Layer<EffectLogger, never, never>;
+export declare class EffectLogger extends EffectLogger_base {
+    static readonly [entityKind]: string;
+    /**
+     * The default layer providing a no-op logger.
+     */
+    static readonly Default: Layer.Layer<EffectLogger, never, never>;
+    /**
+     * Creates an EffectLoggerShape from a standard Drizzle logger.
+     *
+     * @param logger - A Drizzle logger instance implementing the `Logger` interface.
+     * @returns A new EffectLoggerShape that delegates to the provided Drizzle logger.
+     *
+     * @example
+     * ```ts
+     * const drizzleLogger = new DefaultLogger();
+     * const effectLogger = EffectLogger.fromDrizzle(drizzleLogger);
+     * ```
+     */
+    static fromDrizzle(logger: Logger): EffectLoggerShape;
+    /**
+     * Creates a Layer that provides an EffectLogger from a standard Drizzle logger.
+     *
+     * @param logger - A Drizzle logger instance implementing the `Logger` interface.
+     * @returns A Layer that provides the EffectLogger service.
+     *
+     * @example
+     * ```ts
+     * const drizzleLogger = new DefaultLogger();
+     * const db = yield* PgDrizzle.make({ relations }).pipe(
+     *   Effect.provide(EffectLogger.layerFromDrizzle(drizzleLogger)),
+     *   Effect.provide(PgDrizzle.DefaultServices),
+     * );
+     * ```
+     */
+    static layerFromDrizzle(logger: Logger): Layer.Layer<EffectLogger, never, never>;
+    /**
+     * A Layer that provides an EffectLogger with Effect-based logging.
+     *
+     * This layer logs queries using `Effect.log()` with annotations for the query
+     * SQL and parameters. Use this when you want query logging integrated with
+     * Effect's logging infrastructure.
+     *
+     * @example
+     * ```ts
+     * const db = yield* PgDrizzle.make({ relations }).pipe(
+     *   Effect.provide(EffectLogger.layer),
+     *   Effect.provide(PgDrizzle.DefaultServices),
+     * );
+     * ```
+     */
+    static layer: Layer.Layer<EffectLogger, never, never>;
 }
-//#endregion
-export { EffectLogger, EffectLoggerShape };
-//# sourceMappingURL=logger.d.cts.map
+export {};