@shivaedev/sql 0.36.1 → 0.38.0

package/src/repositoryQueries.ts

@@ -3,12 +3,15 @@ import type { Model } from "effect/schema";
 import { SqlClient } from "effect/sql";
 import type { SqlError } from "effect/sql/SqlError";
 import type { Fragment } from "effect/sql/Statement";
+import { groupColumns } from "#adapters/groupColumns.ts";
+import { storageSchema } from "#adapters/storageSchema.ts";
 import type { Aggregate } from "#aggregateQuery.ts";
 import { latestPerGroup as makeLatestPerGroup } from "#latestPerGroup.ts";
 import { makeAggregate } from "#makeAggregate.ts";
 import { makeQueryClauses } from "#makeQueryClauses.ts";
 import type { FindMany, LatestPerGroup } from "#repository.ts";
 import { makeFilter } from "#repositoryFilter.ts";
+import { sqlNameTransforms } from "#sqlNameTransforms.ts";
 
 type Key<TModel extends Model.Any> = Extract<keyof TModel["fields"] & keyof Row<TModel>, string>;
 type Row<TModel extends Model.Any> = Schema.Struct.Type<TModel["fields"]>;
@@ -53,6 +56,7 @@ export function makeQueries<TModel extends Model.Any>(
 ): Effect.Effect<Queries<TModel>, never, SqlClient.SqlClient> {
 	return Effect.fnUntraced(function* () {
 		const sql = yield* SqlClient.SqlClient;
+		const nameTransforms = yield* sqlNameTransforms;
 		const { fieldAt, where } = yield* makeFilter(model);
 		const readLatest = yield* makeLatestPerGroup(model, options.tableName);
 		const { decodeLimit, orderClause, limitClause } = yield* makeQueryClauses(fieldAt);
@@ -77,7 +81,7 @@ export function makeQueries<TModel extends Model.Any>(
 				const predicate = yield* where(query.where, true, true);
 				const order = yield* orderClause(query.orderBy);
 				const limit = yield* limitClause(query.limit);
-				return sql`select ${sql.csv(keys.map((key) => sql`${sql(key)}`))} from ${sql(options.tableName)} where ${predicate} ${order} ${limit}`;
+				return sql`select ${sql.csv(groupColumns(model.fields, keys).map(({ column }) => sql`${sql(column)}`))} from ${sql(options.tableName)} where ${predicate} ${order} ${limit}`;
 			});
 			return { fields, statement };
 		}
@@ -93,7 +97,7 @@ export function makeQueries<TModel extends Model.Any>(
 			return Effect.gen(function* () {
 				const selected = select(query);
 				const rows = yield* sql`${yield* selected.statement}`;
-				return yield* Schema.decodeUnknownEffect(Schema.Array(Schema.Struct(selected.fields)))(rows);
+				return yield* Schema.decodeUnknownEffect(Schema.Array(storageSchema(Schema.Struct(selected.fields), selected.fields, nameTransforms)))(rows);
 			}).pipe(Effect.withSpan(`${options.spanPrefix}.findMany`));
 		}
 		function latestPerGroup(query: LatestPerGroup<TModel>): ReturnType<Queries<TModel>["latestPerGroup"]>;

package/src/repositoryUpdate.ts

@@ -8,11 +8,11 @@ export type UpdateInput<TModel extends Model.Any> = {
 	readonly [TKey in keyof TModel["update"]["Type"]]: WithoutOverride<TModel["update"]["Type"][TKey]>;
 };
 
-type Column<TModel extends Model.Any, TId extends PropertyKey> = Exclude<Extract<keyof UpdateInput<TModel>, string>, TId>;
-type Selected<TModel extends Model.Any, TId extends PropertyKey, TColumn extends PropertyKey> = Required<
+export type Column<TModel extends Model.Any, TId extends PropertyKey> = Exclude<Extract<keyof UpdateInput<TModel>, string>, TId>;
+export type Selected<TModel extends Model.Any, TId extends PropertyKey, TColumn extends PropertyKey> = Required<
 	Pick<UpdateInput<TModel>, Extract<TId | TColumn, keyof UpdateInput<TModel>>>
 >;
-interface Columns<TColumn> {
+export interface Columns<TColumn> {
 	readonly columns: readonly [TColumn, ...TColumn[]];
 }
 type WriteResult<TModel extends Model.Any, A, E = never> = Effect.Effect<

package/src/repositoryWrites.ts

@@ -1,9 +1,11 @@
 import { Effect, Schema } from "effect";
 import type { Model } from "effect/schema";
 import { SqlClient, SqlSchema } from "effect/sql";
+import { storageSchema } from "#adapters/storageSchema.ts";
 import type { RepositoryChanges } from "#repositoryChanges.ts";
 import { makeFilter } from "#repositoryFilter.ts";
 import { selectedUpdate } from "#repositoryUpdate.ts";
+import { sqlNameTransforms } from "#sqlNameTransforms.ts";
 
 export const repositoryWrites = Effect.fnUntraced(function* (
 	model: Model.Any,
@@ -11,6 +13,7 @@ export const repositoryWrites = Effect.fnUntraced(function* (
 	changes: RepositoryChanges,
 ) {
 	const sql = yield* SqlClient.SqlClient;
+	const nameTransforms = yield* sqlNameTransforms;
 	const { idColumns, tableName, spanPrefix } = options;
 	const { where } = yield* makeFilter(model);
 	const record = Schema.decodeUnknownEffect(Schema.Record(Schema.String, Schema.Unknown));
@@ -33,17 +36,29 @@ export const repositoryWrites = Effect.fnUntraced(function* (
 			),
 		);
 	}
-	const insertRow = SqlSchema.findOne({ execute: insert, Request: model.insert, Result: model });
-	const insertVoid = SqlSchema.void({ execute: insert, Request: model.insert });
-	const updateRow = SqlSchema.findOne({ execute: update, Request: model.update, Result: model });
-	const updateVoid = SqlSchema.void({ execute: update, Request: model.update });
+	const insertRow = SqlSchema.findOne({
+		execute: insert,
+		Request: storageSchema(model.insert, model.fields, nameTransforms),
+		Result: storageSchema(model, model.fields, nameTransforms),
+	});
+	const insertVoid = SqlSchema.void({ execute: insert, Request: storageSchema(model.insert, model.fields, nameTransforms) });
+	const updateRow = SqlSchema.findOne({
+		execute: update,
+		Request: storageSchema(model.update, model.fields, nameTransforms),
+		Result: storageSchema(model, model.fields, nameTransforms),
+	});
+	const updateVoid = SqlSchema.void({ execute: update, Request: storageSchema(model.update, model.fields, nameTransforms) });
 	function selected(input: unknown, columns: readonly string[], returning: boolean) {
 		return Effect.gen(function* () {
 			const row = yield* record(input);
 			const Request = yield* selectedUpdate(model, columns, idColumns, row);
 			return yield* returning
-				? SqlSchema.findOne({ execute: update, Request, Result: model })(row)
-				: SqlSchema.void({ execute: update, Request })(row);
+				? SqlSchema.findOne({
+						execute: update,
+						Request: storageSchema(Request, model.fields, nameTransforms),
+						Result: storageSchema(model, model.fields, nameTransforms),
+					})(row)
+				: SqlSchema.void({ execute: update, Request: storageSchema(Request, model.fields, nameTransforms) })(row);
 		});
 	}
 	const idColumn = idColumns[0] ?? "";

package/src/setWorkerReleaseActive.ts

@@ -0,0 +1,17 @@
+import { Effect } from "effect";
+import type { initializeWorkerRelease } from "./initializeWorkerRelease.ts";
+
+export function setWorkerReleaseActive(state: Effect.Success<typeof initializeWorkerRelease>) {
+	return (next: boolean) =>
+		state
+			.locked(
+				Effect.gen(function* () {
+					if (next === state.active) {
+						return;
+					}
+					state.active = next;
+					yield* Effect.forEach(state.controls, (control) => control(state.active), { concurrency: "unbounded", discard: true });
+				}),
+			)
+			.pipe(Effect.uninterruptible);
+}

package/src/sqlNameTransforms.ts

@@ -0,0 +1,9 @@
+import { Effect } from "effect";
+import { SqlClient } from "effect/sql";
+import type { SqlNameTransforms } from "#clientOptions.ts";
+
+export const sqlNameTransforms = Effect.gen(function* () {
+	const client = yield* SqlClient.SqlClient;
+	const namedClient: SqlClient.SqlClient & { readonly config?: SqlNameTransforms } = client;
+	return namedClient.config;
+});

package/src/upsertResult.ts

@@ -1,6 +1,8 @@
 import { Effect, Schema } from "effect";
 import type { Model } from "effect/schema";
 import { SqlClient } from "effect/sql";
+import { storageSchema } from "#adapters/storageSchema.ts";
+import type { SqlNameTransforms } from "#clientOptions.ts";
 
 export interface UpsertRow<TRow> {
 	readonly inserted: boolean;
@@ -12,8 +14,8 @@ export const upsertReturning = Effect.fnUntraced(function* () {
 	return sql`*, (xmax = 0) as ${sql("effectSqlInserted")}`;
 });
 
-export function makeUpsertDecoder(model: Model.Any) {
-	const decode = Schema.decodeUnknownEffect(model);
+export function makeUpsertDecoder(model: Model.Any, names?: SqlNameTransforms) {
+	const decode = Schema.decodeUnknownEffect(storageSchema(model, model.fields, names));
 	return (row: Readonly<Record<string, unknown>> | undefined) =>
 		Effect.map(decode(row), (decoded) => ({ inserted: row?.effectSqlInserted === true, row: decoded }));
 }

package/src/versionedRepository.ts

@@ -2,10 +2,12 @@ import { Effect, Option, Schema } from "effect";
 import type { Model } from "effect/schema";
 import { SqlClient, type SqlModel } from "effect/sql";
 import type { SqlError } from "effect/sql/SqlError";
+import { storageSchema } from "#adapters/storageSchema.ts";
 import type { PrimaryKey, Repository } from "#compositeRepository.ts";
 import type { OptimisticConcurrencyError } from "#repository.ts";
 import type { RepositoryChanges } from "#repositoryChanges.ts";
-import type { UpdateInput } from "#repositoryUpdate.ts";
+import type { Column, Columns, Selected, UpdateInput } from "#repositoryUpdate.ts";
+import { sqlNameTransforms } from "#sqlNameTransforms.ts";
 import { type VersionedOptions, versionedStatements } from "#versionedStatements.ts";
 
 export type IdColumn<TModel extends Model.Any> = keyof TModel["Type"] & keyof TModel["update"]["Type"] & keyof TModel["fields"];
@@ -30,17 +32,34 @@ type WriteError = SqlError | Schema.SchemaError | OptimisticConcurrencyError;
 type KeyColumn<TModel extends Model.Any, TId extends PrimaryKey<TModel>> = TId extends readonly IdColumn<TModel>[]
 	? TId[number]
 	: Extract<TId, IdColumn<TModel>>;
-export interface VersionedWrites<TModel extends Model.Any, TId extends PrimaryKey<TModel>> {
+type RequiredColumn<TModel extends Model.Any, TId extends PrimaryKey<TModel>, TVersion extends PropertyKey> = KeyColumn<TModel, TId> | TVersion;
+interface VersionedUpdate<
+	TModel extends Model.Any,
+	TId extends PrimaryKey<TModel>,
+	TVersion extends VersionColumn<TModel, TId>,
+	A,
+	R = TModel["update"]["EncodingServices"] | TModel["DecodingServices"],
+> {
+	<TColumn extends Column<TModel, RequiredColumn<TModel, TId, TVersion>>>(
+		input: Selected<TModel, RequiredColumn<TModel, TId, TVersion>, TColumn>,
+		options: Columns<TColumn>,
+	): Effect.Effect<A, WriteError, R>;
+	(input: UpdateInput<TModel>): Effect.Effect<A, WriteError, R>;
+}
+
+export interface VersionedWrites<
+	TModel extends Model.Any,
+	TId extends PrimaryKey<TModel>,
+	TVersion extends VersionColumn<TModel, TId> = VersionColumn<TModel, TId>,
+> {
 	readonly delete: (
 		id: TId extends readonly IdColumn<TModel>[] ? Pick<TModel["Type"], TId[number]> : TModel["fields"][Extract<TId, IdColumn<TModel>>]["Type"],
 		expectedVersion: number,
 	) => Effect.Effect<void, WriteError, TModel["fields"][KeyColumn<TModel, TId>]["EncodingServices"]>;
 	readonly insert: Repository<TModel, TId>["insert"];
 	readonly insertVoid: Repository<TModel, TId>["insertVoid"];
-	readonly update: (
-		input: UpdateInput<TModel>,
-	) => Effect.Effect<TModel["Type"], WriteError, TModel["update"]["EncodingServices"] | TModel["DecodingServices"]>;
-	readonly updateVoid: (input: UpdateInput<TModel>) => Effect.Effect<void, WriteError, TModel["update"]["EncodingServices"]>;
+	readonly update: VersionedUpdate<TModel, TId, TVersion, TModel["Type"]>;
+	readonly updateVoid: VersionedUpdate<TModel, TId, TVersion, void, TModel["update"]["EncodingServices"]>;
 }
 
 export const makeVersionedWrites = Effect.fnUntraced(function* (
@@ -48,9 +67,10 @@ export const makeVersionedWrites = Effect.fnUntraced(function* (
 	options: VersionedOptions & { readonly changes: RepositoryChanges; readonly spanPrefix: string },
 ) {
 	const sql = yield* SqlClient.SqlClient;
+	const nameTransforms = yield* sqlNameTransforms;
 	const { spanPrefix, changes } = options;
 	const statements = yield* versionedStatements(model, options);
-	const decodeRow = Schema.decodeUnknownEffect(model);
+	const decodeRow = Schema.decodeUnknownEffect(storageSchema(model, model.fields, nameTransforms));
 	function insert(input: unknown) {
 		return Effect.gen(function* () {
 			const statement = yield* statements.insert(input);
@@ -74,9 +94,9 @@ export const makeVersionedWrites = Effect.fnUntraced(function* (
 			return rows.length === 0 ? Option.none() : Option.some(yield* decodeRow(rows[0]));
 		}).pipe(changes.write, Effect.withSpan(`${spanPrefix}.insertOrIgnore`));
 	}
-	function update(input: Readonly<Record<string, unknown>>) {
+	function update(input: Readonly<Record<string, unknown>>, settings?: { readonly columns: readonly string[] }) {
 		return Effect.gen(function* () {
-			const { statement, classify } = yield* statements.update(input);
+			const { statement, classify } = yield* statements.update(input, settings?.columns);
 			const rows = yield* sql`${statement} returning ${changes.returning()}`;
 			if (rows.length === 0) {
 				return yield* classify();
@@ -85,9 +105,9 @@ export const makeVersionedWrites = Effect.fnUntraced(function* (
 			return yield* decodeRow(rows[0]);
 		}).pipe(changes.write, Effect.withSpan(`${spanPrefix}.update`));
 	}
-	function updateVoid(input: Readonly<Record<string, unknown>>) {
+	function updateVoid(input: Readonly<Record<string, unknown>>, settings?: { readonly columns: readonly string[] }) {
 		return Effect.gen(function* () {
-			const { statement, classify } = yield* statements.update(input);
+			const { statement, classify } = yield* statements.update(input, settings?.columns);
 			const rows = yield* sql`${statement} returning ${changes.returning()}`;
 			if (rows.length === 0) {
 				return yield* classify();

package/src/versionedStatements.ts

@@ -1,8 +1,11 @@
 import { Effect, Schema } from "effect";
 import type { Model } from "effect/schema";
 import { SqlClient } from "effect/sql";
+import { storageSchema } from "#adapters/storageSchema.ts";
 import { makeConflictClause } from "#makeConflictClause.ts";
 import type { OptimisticConcurrencyError } from "#repository.ts";
+import { selectedUpdate } from "#repositoryUpdate.ts";
+import { sqlNameTransforms } from "#sqlNameTransforms.ts";
 
 const Version = Schema.Number.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0));
 export interface VersionedOptions {
@@ -16,6 +19,7 @@ export interface VersionedOptions {
 
 export const versionedStatements = Effect.fnUntraced(function* (model: Model.Any, options: VersionedOptions) {
 	const sql = yield* SqlClient.SqlClient;
+	const nameTransforms = yield* sqlNameTransforms;
 	const { tableName, idColumns, versionColumn, conflict } = options;
 	const entries: [string, Schema.Constraint][] = [];
 	for (const column of idColumns) {
@@ -31,8 +35,8 @@ export const versionedStatements = Effect.fnUntraced(function* (model: Model.Any
 		return yield* Effect.die(new Error(`Unknown version column: ${versionColumn}`));
 	}
 	const encodeVersion = Schema.encodeEffect(versionSchema);
-	const encodeInsert = Schema.encodeEffect(model.insert);
-	const encodeUpdate = Schema.encodeEffect(model.update);
+	const encodeInsert = Schema.encodeEffect(storageSchema(model.insert, model.fields, nameTransforms));
+	const encodeUpdate = Schema.encodeEffect(storageSchema(model.update, model.fields, nameTransforms));
 	const record = Schema.decodeUnknownEffect(Schema.Record(Schema.String, Schema.Unknown));
 	const validateVersion = Schema.decodeUnknownEffect(Version);
 	const clause =
@@ -59,9 +63,15 @@ export const versionedStatements = Effect.fnUntraced(function* (model: Model.Any
 			return sql`insert into ${sql(tableName)} ${sql.insert(encoded)} ${suffix}`;
 		});
 	}
-	function update(input: Readonly<Record<string, unknown>>) {
+	function update(input: Readonly<Record<string, unknown>>, columns?: readonly string[]) {
 		return Effect.gen(function* () {
-			const encoded = yield* record(yield* encodeUpdate(input));
+			const encoded = yield* record(
+				yield* columns === undefined
+					? encodeUpdate(input)
+					: Effect.flatMap(selectedUpdate(model, columns, [...idColumns, versionColumn], input), (schema) =>
+							Schema.encodeEffect(storageSchema(schema, model.fields, nameTransforms))(input),
+						),
+			);
 			const expectedVersion = yield* validateVersion(encoded[versionColumn]);
 			const assignments = Object.entries(encoded).filter(([column]) => !idColumns.includes(column) && column !== versionColumn);
 			const set = sql.csv([