@shivaedev/effect-prisma 0.8.0 → 0.9.0

package/src/internal/relation-stream.ts

@@ -6,17 +6,18 @@ import { fromPrismaPromise } from "./promise.ts";
 import { executeQuery } from "./query-execution.ts";
 import { type RelationRecipe, replayRecipe } from "./recipe.ts";
 
-const collectRows = (iterable: AsyncIterable<unknown>): Effect.Effect<unknown[], PrismaError> =>
-	fromPrismaPromise(async () => {
+function collectRows(iterable: AsyncIterable<unknown>): Effect.Effect<unknown[], PrismaError> {
+	return fromPrismaPromise(async () => {
 		const rows: unknown[] = [];
 		for await (const row of iterable) {
 			rows.push(row);
 		}
 		return rows;
 	});
+}
 
-export const makeRelationStream = <Models extends object, Contract extends AnyPostgresContract>(
-	resolveExecutor: Effect.Effect<DatabaseExecutor<Models, Contract>, PrismaError>,
+export const makeRelationStream = <TModels extends object, TContract extends AnyPostgresContract>(
+	resolveExecutor: Effect.Effect<DatabaseExecutor<TModels, TContract>, PrismaError>,
 	recipe: RelationRecipe,
 ): Stream.Stream<unknown, PrismaError> =>
 	Stream.unwrap(

package/src/internal/sqlite-datetime.ts

@@ -14,13 +14,15 @@ const zonelessDatetime = /^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2}(?::\d{2})?(?:\.\d
 // with no zone, and `new Date` reads that form as local time. Values with a zone and date-only values already read as UTC.
 export const normalizeSqliteDatetime = (value: string): string => value.replace(zonelessDatetime, "$1T$2Z");
 
-const decodeAsUtc = (codec: ContractCodec): ContractCodec => ({
-	decode: (wire: CodecWire, context) => codec.decode(typeof wire === "string" ? normalizeSqliteDatetime(wire) : wire, context),
-	decodeJson: (json: CodecJson) => codec.decodeJson(typeof json === "string" ? normalizeSqliteDatetime(json) : json),
-	encode: (value, context) => codec.encode(value, context),
-	encodeJson: (value) => codec.encodeJson(value),
-	id: sqliteDatetimeCodecId,
-});
+function decodeAsUtc(codec: ContractCodec): ContractCodec {
+	return {
+		decode: (wire: CodecWire, context) => codec.decode(typeof wire === "string" ? normalizeSqliteDatetime(wire) : wire, context),
+		decodeJson: (json: CodecJson) => codec.decodeJson(typeof json === "string" ? normalizeSqliteDatetime(json) : json),
+		encode: (value, context) => codec.encode(value, context),
+		encodeJson: (value) => codec.encodeJson(value),
+		id: sqliteDatetimeCodecId,
+	};
+}
 
 // The registry resolves codecs for rows and included relations alike, and Prisma Next rejects a second descriptor for a registered
 // codec id, so wrapping the registry is the one way to cover every read. It must run before the first query, which reads the
@@ -30,7 +32,7 @@ export const decodeSqliteDatetimesAsUtc = (context: ExecutionContext<AnySqlContr
 	const descriptors = context.codecDescriptors;
 	const utcCodecs = new WeakMap<ContractCodec, ContractCodec>();
 
-	const wrap = (codec: ContractCodec): ContractCodec => {
+	function wrap(codec: ContractCodec): ContractCodec {
 		const existing = utcCodecs.get(codec);
 		if (existing !== undefined) {
 			return existing;
@@ -38,7 +40,7 @@ export const decodeSqliteDatetimesAsUtc = (context: ExecutionContext<AnySqlContr
 		const utc = decodeAsUtc(codec);
 		utcCodecs.set(codec, utc);
 		return utc;
-	};
+	}
 
 	const utcRegistry: CodecRegistry = {
 		forCodecRef: (reference) => {

package/src/internal/testing.ts

@@ -3,28 +3,28 @@ import type { PrismaError } from "#error.ts";
 
 export const DatabaseTestingTypeId: unique symbol = Symbol.for("@shivaedev/effect-prisma/DatabaseTesting");
 
-export interface DatabaseTesting<DatabaseId> {
+export interface DatabaseTesting<TDatabaseId> {
 	readonly withTestTransaction: <A, E, R>(
-		program: Effect.Effect<A, E, R> & (DatabaseId extends R ? unknown : never),
-	) => Effect.Effect<A, E | PrismaError, DatabaseId | Exclude<R, DatabaseId>>;
+		program: Effect.Effect<A, E, R> & (TDatabaseId extends R ? unknown : never),
+	) => Effect.Effect<A, E | PrismaError, TDatabaseId | Exclude<R, TDatabaseId>>;
 }
 
-export interface DatabaseWithTesting<DatabaseId> {
-	readonly [DatabaseTestingTypeId]: DatabaseTesting<DatabaseId>;
+export interface DatabaseWithTesting<TDatabaseId> {
+	readonly [DatabaseTestingTypeId]: DatabaseTesting<TDatabaseId>;
 }
 
 // makeSqlDatabase installs the testing hooks for the database's own service identifier.
-function testingFor<DatabaseId>(testing: object): DatabaseTesting<DatabaseId>;
+function testingFor<TDatabaseId>(testing: object): DatabaseTesting<TDatabaseId>;
 function testingFor(testing: object): unknown {
 	return testing;
 }
 
-export const getDatabaseTesting = <DatabaseId>(database: object): DatabaseTesting<DatabaseId> => {
+export const getDatabaseTesting = <TDatabaseId>(database: object): DatabaseTesting<TDatabaseId> => {
 	const testing: unknown = Reflect.get(database, DatabaseTestingTypeId);
 
 	if (typeof testing !== "object" || testing === null || typeof Reflect.get(testing, "withTestTransaction") !== "function") {
 		throw new TypeError("The database was not created by this copy of @shivaedev/effect-prisma");
 	}
 
-	return testingFor<DatabaseId>(testing);
+	return testingFor<TDatabaseId>(testing);
 };

package/src/internal/transaction.ts

@@ -5,26 +5,26 @@ import { type SettledConnection, type SettledTransaction, settleConnection } fro
 import type { AnySqlContract, DatabaseExecutor } from "./executor.ts";
 import { fromPrismaPromise } from "./promise.ts";
 
-export type TransactionOrm<Contract extends AnySqlContract> = ReturnType<typeof orm<Contract>>;
+export type TransactionOrm<TContract extends AnySqlContract> = ReturnType<typeof orm<TContract>>;
 
 export const withTransactionSemaphore = <A, E, R>(
 	semaphore: Semaphore.Semaphore | undefined,
 	transaction: Effect.Effect<A, E, R>,
 ): Effect.Effect<A, E, R> => (semaphore === undefined ? transaction : semaphore.withPermit(transaction));
 
-export interface TransactionResource<Models extends object, Contract extends AnySqlContract> {
+export interface TransactionResource<TModels extends object, TContract extends AnySqlContract> {
 	readonly connection: SettledConnection;
-	readonly executor: DatabaseExecutor<Models, Contract> & {
+	readonly executor: DatabaseExecutor<TModels, TContract> & {
 		readonly querySemaphore: Semaphore.Semaphore;
 	};
 	readonly transaction: SettledTransaction;
 }
 
-export const acquireTransaction = <Models extends object, Contract extends AnySqlContract>(
-	current: DatabaseExecutor<Models, Contract>,
-	models: (orm: TransactionOrm<Contract>) => Models,
+export const acquireTransaction = <TModels extends object, TContract extends AnySqlContract>(
+	current: DatabaseExecutor<TModels, TContract>,
+	models: (orm: TransactionOrm<TContract>) => TModels,
 	mode: "test" | "transaction",
-): Effect.Effect<TransactionResource<Models, Contract>, PrismaError> =>
+): Effect.Effect<TransactionResource<TModels, TContract>, PrismaError> =>
 	fromPrismaPromise(async () => {
 		const connection = await current.client.runtime().connection();
 
@@ -58,22 +58,22 @@ export const acquireTransaction = <Models extends object, Contract extends AnySq
 		}
 	});
 
-export const releaseTransaction = <Models extends object, Contract extends AnySqlContract, A, E>(
-	resource: TransactionResource<Models, Contract>,
+export const releaseTransaction = <TModels extends object, TContract extends AnySqlContract, A, E>(
+	resource: TransactionResource<TModels, TContract>,
 	exit: Exit.Exit<A, E>,
 ): Effect.Effect<void, PrismaError> => settleTransaction(resource, exit, true);
 
-export const releaseTestTransaction = <Models extends object, Contract extends AnySqlContract, A, E>(
-	resource: TransactionResource<Models, Contract>,
+export const releaseTestTransaction = <TModels extends object, TContract extends AnySqlContract, A, E>(
+	resource: TransactionResource<TModels, TContract>,
 	exit: Exit.Exit<A, E>,
 ): Effect.Effect<void, PrismaError> => settleTransaction(resource, exit, false);
 
-const settleTransaction = <Models extends object, Contract extends AnySqlContract, A, E>(
-	resource: TransactionResource<Models, Contract>,
+function settleTransaction<TModels extends object, TContract extends AnySqlContract, A, E>(
+	resource: TransactionResource<TModels, TContract>,
 	exit: Exit.Exit<A, E>,
 	commitOnSuccess: boolean,
-): Effect.Effect<void, PrismaError> =>
-	Effect.uninterruptible(
+): Effect.Effect<void, PrismaError> {
+	return Effect.uninterruptible(
 		Effect.sync(() => {
 			resource.executor.liveness.open = false;
 		}).pipe(
@@ -82,3 +82,4 @@ const settleTransaction = <Models extends object, Contract extends AnySqlContrac
 			),
 		),
 	);
+}

package/src/relation/include.ts

@@ -2,18 +2,18 @@ import type { DefaultModelRow, Collection as PrismaCollection, RelationNames } f
 import type { Relation, RelationQuery } from "#relation.ts";
 import type { AnyPostgresContract, IncludedRelationValue, IsToManyRelation, RelatedModelNameOf } from "./include-metadata.ts";
 
-type Simplify<Value> = { [Key in keyof Value]: Value[Key] };
+type Simplify<TValue> = { [TKey in keyof TValue]: TValue[TKey] };
 
-type QueryValue<Query> = Query extends RelationQuery<infer Value, infer _Contract, infer _Model, infer _DatabaseId> ? Value : never;
+type QueryValue<TQuery> = TQuery extends RelationQuery<infer TValue, infer _Contract, infer _Model, infer _DatabaseId> ? TValue : never;
 
-type AcceptRelatedQuery<Query, Contract extends AnyPostgresContract, Model extends string, DatabaseId> = [Query] extends [
-	RelationQuery<infer _Value, infer QueryContract, infer QueryModel, infer QueryDatabaseId>,
+type AcceptRelatedQuery<TQuery, TContract extends AnyPostgresContract, TModel extends string, TDatabaseId> = [TQuery] extends [
+	RelationQuery<infer _Value, infer TQueryContract, infer TQueryModel, infer TQueryDatabaseId>,
 ]
-	? [QueryContract] extends [Contract]
-		? [Contract] extends [QueryContract]
-			? [QueryDatabaseId] extends [DatabaseId]
-				? [DatabaseId] extends [QueryDatabaseId]
-					? QueryModel extends Model
+	? [TQueryContract] extends [TContract]
+		? [TContract] extends [TQueryContract]
+			? [TQueryDatabaseId] extends [TDatabaseId]
+				? [TDatabaseId] extends [TQueryDatabaseId]
+					? TQueryModel extends TModel
 						? unknown
 						: never
 					: never
@@ -22,63 +22,63 @@ type AcceptRelatedQuery<Query, Contract extends AnyPostgresContract, Model exten
 		: never
 	: never;
 
-type IncludedQueryValue<Query, Contract extends AnyPostgresContract, Model extends string, RelationName extends string> =
-	QueryValue<Query> extends ReadonlyArray<infer Row> ? IncludedRelationValue<Contract, Model, RelationName, Row> : QueryValue<Query>;
+type IncludedQueryValue<TQuery, TContract extends AnyPostgresContract, TModel extends string, TRelationName extends string> =
+	QueryValue<TQuery> extends ReadonlyArray<infer TRow> ? IncludedRelationValue<TContract, TModel, TRelationName, TRow> : QueryValue<TQuery>;
 
-type QueryShapeValue<Shape extends Readonly<Record<string, unknown>>> = {
-	readonly [Key in keyof Shape]: QueryValue<Shape[Key]>;
+type QueryShapeValue<TShape extends Readonly<Record<string, unknown>>> = {
+	readonly [TKey in keyof TShape]: QueryValue<TShape[TKey]>;
 };
 
 type AcceptRelatedQueryShape<
-	Shape extends Readonly<Record<string, unknown>>,
-	Contract extends AnyPostgresContract,
-	Model extends string,
-	DatabaseId,
+	TShape extends Readonly<Record<string, unknown>>,
+	TContract extends AnyPostgresContract,
+	TModel extends string,
+	TDatabaseId,
 > = {
-	readonly [Key in keyof Shape]: Shape[Key] & AcceptRelatedQuery<Shape[Key], Contract, Model, DatabaseId>;
+	readonly [TKey in keyof TShape]: TShape[TKey] & AcceptRelatedQuery<TShape[TKey], TContract, TModel, TDatabaseId>;
 };
 
-type WithIncludedRelation<Collection, Contract extends AnyPostgresContract, Model extends string, RelationName extends string, Value> =
-	Collection extends PrismaCollection<Contract, Model, infer Row, infer State>
-		? PrismaCollection<Contract, Model, Simplify<Row & { readonly [Key in RelationName]: Value }>, State>
+type WithIncludedRelation<TCollection, TContract extends AnyPostgresContract, TModel extends string, TRelationName extends string, TValue> =
+	TCollection extends PrismaCollection<TContract, TModel, infer TRow, infer TState>
+		? PrismaCollection<TContract, TModel, Simplify<TRow & { readonly [TKey in TRelationName]: TValue }>, TState>
 		: never;
 
-interface IncludeOverloads<Collection, Contract extends AnyPostgresContract, Model extends string, DatabaseId> {
-	<RelationName extends RelationNames<Contract, Model>>(
-		relationName: RelationName,
+interface IncludeOverloads<TCollection, TContract extends AnyPostgresContract, TModel extends string, TDatabaseId> {
+	<TRelationName extends RelationNames<TContract, TModel>>(
+		relationName: TRelationName,
 	): Relation<
 		WithIncludedRelation<
-			Collection,
-			Contract,
-			Model,
-			RelationName,
-			IncludedRelationValue<Contract, Model, RelationName, DefaultModelRow<Contract, RelatedModelNameOf<Contract, Model, RelationName>>>
+			TCollection,
+			TContract,
+			TModel,
+			TRelationName,
+			IncludedRelationValue<TContract, TModel, TRelationName, DefaultModelRow<TContract, RelatedModelNameOf<TContract, TModel, TRelationName>>>
 		>,
-		Contract,
-		Model,
-		DatabaseId
+		TContract,
+		TModel,
+		TDatabaseId
 	>;
-	<RelationName extends RelationNames<Contract, Model>, Query>(
-		relationName: RelationName,
-		query: Query & AcceptRelatedQuery<Query, Contract, RelatedModelNameOf<Contract, Model, RelationName>, DatabaseId>,
+	<TRelationName extends RelationNames<TContract, TModel>, TQuery>(
+		relationName: TRelationName,
+		query: TQuery & AcceptRelatedQuery<TQuery, TContract, RelatedModelNameOf<TContract, TModel, TRelationName>, TDatabaseId>,
 	): Relation<
-		WithIncludedRelation<Collection, Contract, Model, RelationName, IncludedQueryValue<Query, Contract, Model, RelationName>>,
-		Contract,
-		Model,
-		DatabaseId
+		WithIncludedRelation<TCollection, TContract, TModel, TRelationName, IncludedQueryValue<TQuery, TContract, TModel, TRelationName>>,
+		TContract,
+		TModel,
+		TDatabaseId
 	>;
-	<RelationName extends RelationNames<Contract, Model>, Shape extends Readonly<Record<string, unknown>>>(
-		relationName: RelationName,
-		shape: IsToManyRelation<Contract, Model, RelationName> extends true
-			? keyof Shape extends never
+	<TRelationName extends RelationNames<TContract, TModel>, TShape extends Readonly<Record<string, unknown>>>(
+		relationName: TRelationName,
+		shape: IsToManyRelation<TContract, TModel, TRelationName> extends true
+			? keyof TShape extends never
 				? never
-				: Shape & AcceptRelatedQueryShape<Shape, Contract, RelatedModelNameOf<Contract, Model, RelationName>, DatabaseId>
+				: TShape & AcceptRelatedQueryShape<TShape, TContract, RelatedModelNameOf<TContract, TModel, TRelationName>, TDatabaseId>
 			: never,
-	): Relation<WithIncludedRelation<Collection, Contract, Model, RelationName, QueryShapeValue<Shape>>, Contract, Model, DatabaseId>;
+	): Relation<WithIncludedRelation<TCollection, TContract, TModel, TRelationName, QueryShapeValue<TShape>>, TContract, TModel, TDatabaseId>;
 }
 
-export type IncludeMethod<Collection, Contract, Model extends string, DatabaseId> = Contract extends AnyPostgresContract
-	? Collection extends PrismaCollection<Contract, Model, infer _Row, infer _State>
-		? { include: IncludeOverloads<Collection, Contract, Model, DatabaseId> }
+export type IncludeMethod<TCollection, TContract, TModel extends string, TDatabaseId> = TContract extends AnyPostgresContract
+	? TCollection extends PrismaCollection<TContract, TModel, infer _Row, infer _State>
+		? { include: IncludeOverloads<TCollection, TContract, TModel, TDatabaseId> }
 		: Record<never, never>
 	: Record<never, never>;

package/src/relation.ts

@@ -4,40 +4,40 @@ import type { PrismaError } from "./error.ts";
 
 type AnyFunction = (...arguments_: readonly never[]) => unknown;
 
-export type CollectionResult<Collection> = Collection extends {
-	all: () => infer Result;
+export type CollectionResult<TCollection> = TCollection extends {
+	all: () => infer TResult;
 }
-	? Awaited<Result>
+	? Awaited<TResult>
 	: never;
 
-type NormalizeTerminal<Name, Result> = Name extends "first" ? import("effect").Option.Option<Exclude<Result, null>> : Result;
+type NormalizeTerminal<TName, TResult> = TName extends "first" ? import("effect").Option.Option<Exclude<TResult, null>> : TResult;
 
-type WrapReturn<Name, Result, Contract, Model extends string, DatabaseId> =
-	Result extends PromiseLike<infer Value>
-		? Effect.Effect<NormalizeTerminal<Name, Awaited<Value>>, PrismaError>
-		: Result extends object
-			? Relation<Result, Contract, Model, DatabaseId>
+type WrapReturn<TName, TResult, TContract, TModel extends string, TDatabaseId> =
+	TResult extends PromiseLike<infer TValue>
+		? Effect.Effect<NormalizeTerminal<TName, Awaited<TValue>>, PrismaError>
+		: TResult extends object
+			? Relation<TResult, TContract, TModel, TDatabaseId>
 			: never;
 
-type WrapFunction<Name, Function_, Contract, Model extends string, DatabaseId> = Function_ extends {
-	(...arguments_: infer Arguments1): infer Result1;
-	(...arguments_: infer Arguments2): infer Result2;
-	(...arguments_: infer Arguments3): infer Result3;
-	(...arguments_: infer Arguments4): infer Result4;
-	(...arguments_: infer Arguments5): infer Result5;
-	(...arguments_: infer Arguments6): infer Result6;
+type WrapFunction<TName, TFunction, TContract, TModel extends string, TDatabaseId> = TFunction extends {
+	(...arguments_: infer TArguments1): infer TResult1;
+	(...arguments_: infer TArguments2): infer TResult2;
+	(...arguments_: infer TArguments3): infer TResult3;
+	(...arguments_: infer TArguments4): infer TResult4;
+	(...arguments_: infer TArguments5): infer TResult5;
+	(...arguments_: infer TArguments6): infer TResult6;
 }
-	? ((...arguments_: Arguments1) => WrapReturn<Name, Result1, Contract, Model, DatabaseId>) &
-			((...arguments_: Arguments2) => WrapReturn<Name, Result2, Contract, Model, DatabaseId>) &
-			((...arguments_: Arguments3) => WrapReturn<Name, Result3, Contract, Model, DatabaseId>) &
-			((...arguments_: Arguments4) => WrapReturn<Name, Result4, Contract, Model, DatabaseId>) &
-			((...arguments_: Arguments5) => WrapReturn<Name, Result5, Contract, Model, DatabaseId>) &
-			((...arguments_: Arguments6) => WrapReturn<Name, Result6, Contract, Model, DatabaseId>)
+	? ((...arguments_: TArguments1) => WrapReturn<TName, TResult1, TContract, TModel, TDatabaseId>) &
+			((...arguments_: TArguments2) => WrapReturn<TName, TResult2, TContract, TModel, TDatabaseId>) &
+			((...arguments_: TArguments3) => WrapReturn<TName, TResult3, TContract, TModel, TDatabaseId>) &
+			((...arguments_: TArguments4) => WrapReturn<TName, TResult4, TContract, TModel, TDatabaseId>) &
+			((...arguments_: TArguments5) => WrapReturn<TName, TResult5, TContract, TModel, TDatabaseId>) &
+			((...arguments_: TArguments6) => WrapReturn<TName, TResult6, TContract, TModel, TDatabaseId>)
 	: never;
 
-type FunctionKeys<Value> = {
-	[Key in keyof Value]-?: Value[Key] extends AnyFunction ? Key : never;
-}[keyof Value];
+type FunctionKeys<TValue> = {
+	[TKey in keyof TValue]-?: TValue[TKey] extends AnyFunction ? TKey : never;
+}[keyof TValue];
 
 type ExplicitPrismaMethod =
 	| "aggregate"
@@ -58,25 +58,25 @@ type ExplicitPrismaMethod =
 	| "sum"
 	| "variant";
 
-type RelationMethods<Collection, Contract, Model extends string, DatabaseId> = {
-	readonly [Key in Exclude<FunctionKeys<Collection>, ExplicitPrismaMethod>]: WrapFunction<Key, Collection[Key], Contract, Model, DatabaseId>;
+type RelationMethods<TCollection, TContract, TModel extends string, TDatabaseId> = {
+	readonly [TKey in Exclude<FunctionKeys<TCollection>, ExplicitPrismaMethod>]: WrapFunction<TKey, TCollection[TKey], TContract, TModel, TDatabaseId>;
 };
 
 declare const RelationQueryTypeId: unique symbol;
 
-export type RelationQuery<Value, Contract, Model extends string, DatabaseId> = Effect.Effect<Value, PrismaError> & {
+export type RelationQuery<TValue, TContract, TModel extends string, TDatabaseId> = Effect.Effect<TValue, PrismaError> & {
 	readonly [RelationQueryTypeId]: {
-		readonly contract: Contract;
-		readonly database: (database: DatabaseId) => DatabaseId;
-		readonly model: Model;
+		readonly contract: TContract;
+		readonly database: (database: TDatabaseId) => TDatabaseId;
+		readonly model: TModel;
 	};
 };
 
-export type Relation<Collection, Contract = undefined, Model extends string = string, DatabaseId = undefined> = RelationQuery<
-	CollectionResult<Collection>,
-	Contract,
-	Model,
-	DatabaseId
+export type Relation<TCollection, TContract = undefined, TModel extends string = string, TDatabaseId = undefined> = RelationQuery<
+	CollectionResult<TCollection>,
+	TContract,
+	TModel,
+	TDatabaseId
 > &
-	RelationMethods<Collection, Contract, Model, DatabaseId> &
-	PrismaRelationMethods<Collection, Contract, Model, DatabaseId>;
+	RelationMethods<TCollection, TContract, TModel, TDatabaseId> &
+	PrismaRelationMethods<TCollection, TContract, TModel, TDatabaseId>;

package/src/sqlite.ts

@@ -32,12 +32,14 @@ export interface SqliteDatabaseDefinition<Contract extends AnySqlContract, Ident
 	readonly layer: (options: SqliteDatabaseLayerOptions) => Layer.Layer<DatabaseIdentifier<Contract, Identifier>, PrismaError>;
 }
 
-const clientOptions = ({ path, extensions, middleware, verifyMarker }: SqliteDatabaseLayerOptions) => ({
-	path,
-	...(extensions === undefined ? {} : { extensions }),
-	...(middleware === undefined ? {} : { middleware }),
-	...(verifyMarker === undefined ? {} : { verifyMarker }),
-});
+function clientOptions({ path, extensions, middleware, verifyMarker }: SqliteDatabaseLayerOptions) {
+	return {
+		path,
+		...(extensions === undefined ? {} : { extensions }),
+		...(middleware === undefined ? {} : { middleware }),
+		...(verifyMarker === undefined ? {} : { verifyMarker }),
+	};
+}
 
 export const makeSqliteDatabase =
 	<const Contract extends AnySqlContract>() =>