@apisr/drizzle-model 0.0.1 → 0.0.3

package/src/model/core/thenable.ts

@@ -5,81 +5,90 @@ import type { MethodWithValue } from "../methods/with.ts";
 type AnyObj = Record<string, any>;
 
 type QueryState = {
-  where?: unknown;
-  with?: unknown;
-  raw?: boolean;
-  select?: AnyObj;
-  exclude?: AnyObj;
+	where?: unknown;
+	with?: unknown;
+	raw?: boolean;
+	select?: AnyObj;
+	exclude?: AnyObj;
 };
 
 type MutateKind = "insert" | "update" | "delete" | "upsert";
 
 type MutateState = {
-  kind: MutateKind;
-  where?: unknown;
-  value?: unknown;
-  returnSelect?: AnyObj;
+	kind: MutateKind;
+	where?: unknown;
+	value?: unknown;
+	returnSelect?: AnyObj;
 };
 
 export class ThenableResult<T> implements PromiseLike<T> {
-  protected _execute: () => Promise<T>;
-
-  constructor(execute: () => Promise<T>) {
-    this._execute = execute;
-  }
-
-  then<TResult1 = T, TResult2 = never>(
-    onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
-    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,
-  ): Promise<TResult1 | TResult2> {
-    return this._execute().then(onfulfilled as any, onrejected as any);
-  }
+	protected _execute: () => Promise<T>;
+
+	constructor(execute: () => Promise<T>) {
+		this._execute = execute;
+	}
+
+	then<TResult1 = T, TResult2 = never>(
+		onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
+		onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null
+	): Promise<TResult1 | TResult2> {
+		return this._execute().then(onfulfilled as any, onrejected as any);
+	}
 }
 
 export class QueryResult<T> extends ThenableResult<T> {
-  private state: QueryState;
-  private runner: (state: QueryState) => Promise<T>;
-
-  constructor(state: QueryState, runner: (state: QueryState) => Promise<T>) {
-    super(() => runner(state));
-    this.state = state;
-    this.runner = runner;
-  }
-
-  with(value: MethodWithValue<any, any>): any {
-    return new QueryResult({ ...this.state, with: value }, this.runner) as any;
-  }
-
-  select(value: MethodSelectValue<any>): any {
-    return new QueryResult({ ...this.state, select: value as any }, this.runner) as any;
-  }
-
-  exclude(value: MethodExcludeValue<any>): any {
-    return new QueryResult({ ...this.state, exclude: value as any }, this.runner) as any;
-  }
-
-  raw(): any {
-    return new QueryResult({ ...this.state, raw: true }, this.runner) as any;
-  }
-
-  debug(): any {
-    return this.state;
-  }
+	private state: QueryState;
+	private runner: (state: QueryState) => Promise<T>;
+
+	constructor(state: QueryState, runner: (state: QueryState) => Promise<T>) {
+		super(() => runner(state));
+		this.state = state;
+		this.runner = runner;
+	}
+
+	with(value: MethodWithValue<any, any>): any {
+		return new QueryResult({ ...this.state, with: value }, this.runner) as any;
+	}
+
+	select(value: MethodSelectValue<any>): any {
+		return new QueryResult(
+			{ ...this.state, select: value as any },
+			this.runner
+		) as any;
+	}
+
+	exclude(value: MethodExcludeValue<any>): any {
+		return new QueryResult(
+			{ ...this.state, exclude: value as any },
+			this.runner
+		) as any;
+	}
+
+	raw(): any {
+		return new QueryResult({ ...this.state, raw: true }, this.runner) as any;
+	}
+
+	debug(): any {
+		return this.state;
+	}
 }
 
 export class MutateResult<T> extends ThenableResult<T> {
-  private state: MutateState;
-  private runner: (state: MutateState) => Promise<T>;
-
-  constructor(state: MutateState, runner: (state: MutateState) => Promise<T>) {
-    super(() => runner(state));
-    this.state = state;
-    this.runner = runner;
-  }
-
-  return(value?: AnyObj): any {
-    return new MutateResult({ ...this.state, returnSelect: value }, this.runner) as any;
-  }
+	private state: MutateState;
+	private runner: (state: MutateState) => Promise<T>;
+
+	constructor(state: MutateState, runner: (state: MutateState) => Promise<T>) {
+		super(() => runner(state));
+		this.state = state;
+		this.runner = runner;
+	}
+
+	return(value?: AnyObj): any {
+		return new MutateResult(
+			{ ...this.state, returnSelect: value },
+			this.runner
+		) as any;
+	}
 }
 
 export type { QueryState, MutateState, MutateKind };

package/src/model/core/transform.ts

@@ -1,45 +1,65 @@
 type AnyObj = Record<string, any>;
 
 export function applySelect(value: any, select: AnyObj): any {
-  if (value == null) return value;
-  if (Array.isArray(value)) return value.map((v) => applySelect(v, select));
-  if (typeof value !== "object") return value;
+	if (value == null) {
+		return value;
+	}
+	if (Array.isArray(value)) {
+		return value.map((v) => applySelect(v, select));
+	}
+	if (typeof value !== "object") {
+		return value;
+	}
 
-  const out: AnyObj = {};
-  for (const [key, sel] of Object.entries(select)) {
-    if (sel === true) {
-      out[key] = (value as any)[key];
-      continue;
-    }
-    if (sel && typeof sel === "object") {
-      out[key] = applySelect((value as any)[key], sel as AnyObj);
-    }
-  }
-  return out;
+	const out: AnyObj = {};
+	for (const [key, sel] of Object.entries(select)) {
+		if (sel === true) {
+			out[key] = (value as any)[key];
+			continue;
+		}
+		if (sel && typeof sel === "object") {
+			out[key] = applySelect((value as any)[key], sel as AnyObj);
+		}
+	}
+	return out;
 }
 
 export function applyExclude(value: any, exclude: AnyObj): any {
-  if (value == null) return value;
-  if (Array.isArray(value)) return value.map((v) => applyExclude(v, exclude));
-  if (typeof value !== "object") return value;
+	if (value == null) {
+		return value;
+	}
+	if (Array.isArray(value)) {
+		return value.map((v) => applyExclude(v, exclude));
+	}
+	if (typeof value !== "object") {
+		return value;
+	}
 
-  const out: AnyObj = { ...(value as AnyObj) };
-  for (const [key, ex] of Object.entries(exclude)) {
-    if (ex === true) {
-      delete out[key];
-      continue;
-    }
-    if (ex && typeof ex === "object" && key in out) {
-      out[key] = applyExclude(out[key], ex as AnyObj);
-    }
-  }
-  return out;
+	const out: AnyObj = { ...(value as AnyObj) };
+	for (const [key, ex] of Object.entries(exclude)) {
+		if (ex === true) {
+			delete out[key];
+			continue;
+		}
+		if (ex && typeof ex === "object" && key in out) {
+			out[key] = applyExclude(out[key], ex as AnyObj);
+		}
+	}
+	return out;
 }
 
 export function applyFormat(value: any, format: any): any {
-  if (!format) return value;
-  if (value == null) return value;
-  if (Array.isArray(value)) return value.map((v) => applyFormat(v, format));
-  if (typeof value !== "object") return value;
-  return format(value);
+	if (!format) {
+		return value;
+	}
+	if (value == null) {
+		return value;
+	}
+	if (Array.isArray(value)) {
+		return value.map((v) => applyFormat(v, format));
+	}
+	if (typeof value !== "object") {
+		return value;
+	}
+	return format(value);
 }

package/src/model/core/where.ts

@@ -1,183 +1,249 @@
+import type { SQL } from "drizzle-orm";
 import {
-  and,
-  between,
-  eq,
-  gt,
-  gte,
-  ilike,
-  inArray,
-  isNull,
-  like,
-  lt,
-  lte,
-  ne,
-  notBetween,
-  notInArray,
-  or,
+	and,
+	between,
+	eq,
+	gt,
+	gte,
+	ilike,
+	inArray,
+	isNull,
+	like,
+	lt,
+	lte,
+	ne,
+	notBetween,
+	notInArray,
+	or,
 } from "drizzle-orm";
-import type { SQL } from "drizzle-orm";
 import type { EscapedValue } from "../query/operations.ts";
 
 type AnyObj = Record<string, any>;
 
 function isPromiseLike(value: any): value is PromiseLike<any> {
-  return value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+	return (
+		value &&
+		(typeof value === "object" || typeof value === "function") &&
+		typeof value.then === "function"
+	);
 }
 
 function isEscapedValue(value: any): value is EscapedValue<any> {
-  return value && typeof value === "object" && ("equal" in value || value.__kind === "esc-op");
+	return (
+		value &&
+		typeof value === "object" &&
+		("equal" in value || value.__kind === "esc-op")
+	);
 }
 
-function unwrapEscapedValue(column: any, value: any): { sql?: SQL; value?: any } {
-  if (!isEscapedValue(value)) return { value };
-
-  if ((value as any).__kind === "esc-op") {
-    return {
-      sql: (value as any).op(column, (value as any).value),
-    };
-  }
-
-  return {
-    value: (value as any).equal,
-  };
+function unwrapEscapedValue(
+	column: any,
+	value: any
+): { sql?: SQL; value?: any } {
+	if (!isEscapedValue(value)) {
+		return { value };
+	}
+
+	if ((value as any).__kind === "esc-op") {
+		return {
+			sql: (value as any).op(column, (value as any).value),
+		};
+	}
+
+	return {
+		value: (value as any).equal,
+	};
 }
 
 function compileColumnValue(column: any, value: any): SQL | undefined {
-  if (isEscapedValue(value)) {
-    if ((value as any).__kind === "esc-op") {
-      return (value as any).op(column, (value as any).value);
-    }
-    return eq(column, (value as any).equal);
-  }
-
-  if (value && typeof value === "object" && !Array.isArray(value)) {
-    const parts: SQL[] = [];
-
-    const pushIf = (sql: SQL | undefined) => {
-      if (sql) parts.push(sql);
-    };
-
-    const v: AnyObj = value;
-    if ("eq" in v) {
-      const u = unwrapEscapedValue(column, v.eq);
-      pushIf(u.sql ?? eq(column, u.value));
-    }
-    if ("equal" in v) {
-      const u = unwrapEscapedValue(column, v.equal);
-      pushIf(u.sql ?? eq(column, u.value));
-    }
-    if ("not" in v) {
-      const u = unwrapEscapedValue(column, v.not);
-      pushIf(u.sql ?? ne(column, u.value));
-    }
-    if ("in" in v) {
-      const arr = (v.in ?? []).map((item: any) => unwrapEscapedValue(column, item));
-      const sqls = arr.map((x: { sql?: SQL; value?: any }) => x.sql).filter(Boolean) as SQL[];
-      const values = arr.map((x: { sql?: SQL; value?: any }) => x.value).filter((x: any) => x !== undefined);
-      if (sqls.length) pushIf(or(...sqls));
-      if (values.length) pushIf(inArray(column, values));
-    }
-    if ("nin" in v) {
-      const arr = (v.nin ?? []).map((item: any) => unwrapEscapedValue(column, item));
-      const sqls = arr.map((x: { sql?: SQL; value?: any }) => x.sql).filter(Boolean) as SQL[];
-      const values = arr.map((x: { sql?: SQL; value?: any }) => x.value).filter((x: any) => x !== undefined);
-      if (sqls.length) pushIf(or(...sqls));
-      if (values.length) pushIf(notInArray(column, values));
-    }
-    if ("isNull" in v) pushIf(v.isNull ? isNull(column) : undefined);
-
-    if ("gt" in v) {
-      const u = unwrapEscapedValue(column, v.gt);
-      pushIf(u.sql ?? gt(column, u.value));
-    }
-    if ("gte" in v) {
-      const u = unwrapEscapedValue(column, v.gte);
-      pushIf(u.sql ?? gte(column, u.value));
-    }
-    if ("lt" in v) {
-      const u = unwrapEscapedValue(column, v.lt);
-      pushIf(u.sql ?? lt(column, u.value));
-    }
-    if ("lte" in v) {
-      const u = unwrapEscapedValue(column, v.lte);
-      pushIf(u.sql ?? lte(column, u.value));
-    }
-    if ("between" in v) {
-      const a = unwrapEscapedValue(column, v.between?.[0]);
-      const b = unwrapEscapedValue(column, v.between?.[1]);
-      if (a.sql) pushIf(a.sql);
-      if (b.sql) pushIf(b.sql);
-      pushIf(between(column, a.value, b.value));
-    }
-    if ("notBetween" in v) {
-      const a = unwrapEscapedValue(column, v.notBetween?.[0]);
-      const b = unwrapEscapedValue(column, v.notBetween?.[1]);
-      if (a.sql) pushIf(a.sql);
-      if (b.sql) pushIf(b.sql);
-      pushIf(notBetween(column, a.value, b.value));
-    }
-
-    if ("like" in v) {
-      const u = unwrapEscapedValue(column, v.like);
-      pushIf(u.sql ?? like(column, u.value));
-    }
-    if ("ilike" in v) {
-      const u = unwrapEscapedValue(column, v.ilike);
-      pushIf(u.sql ?? ilike(column, u.value));
-    }
-
-    if (Array.isArray(v.or)) {
-      const sub = v.or
-        .map((item: any) => compileColumnValue(column, item))
-        .filter(Boolean) as SQL[];
-      if (sub.length) pushIf(or(...sub));
-    }
-
-    if (Array.isArray(v.and)) {
-      const sub = v.and
-        .map((item: any) => compileColumnValue(column, item))
-        .filter(Boolean) as SQL[];
-      if (sub.length) pushIf(and(...sub));
-    }
-
-    if (!parts.length) return undefined;
-    return parts.length === 1 ? parts[0] : and(...parts);
-  }
-
-  return eq(column, value);
+	if (isEscapedValue(value)) {
+		if ((value as any).__kind === "esc-op") {
+			return (value as any).op(column, (value as any).value);
+		}
+		return eq(column, (value as any).equal);
+	}
+
+	if (value && typeof value === "object" && !Array.isArray(value)) {
+		const parts: SQL[] = [];
+
+		const pushIf = (sql: SQL | undefined) => {
+			if (sql) {
+				parts.push(sql);
+			}
+		};
+
+		const v: AnyObj = value;
+		if ("eq" in v) {
+			const u = unwrapEscapedValue(column, v.eq);
+			pushIf(u.sql ?? eq(column, u.value));
+		}
+		if ("equal" in v) {
+			const u = unwrapEscapedValue(column, v.equal);
+			pushIf(u.sql ?? eq(column, u.value));
+		}
+		if ("not" in v) {
+			const u = unwrapEscapedValue(column, v.not);
+			pushIf(u.sql ?? ne(column, u.value));
+		}
+		if ("in" in v) {
+			const arr = (v.in ?? []).map((item: any) =>
+				unwrapEscapedValue(column, item)
+			);
+			const sqls = arr
+				.map((x: { sql?: SQL; value?: any }) => x.sql)
+				.filter(Boolean) as SQL[];
+			const values = arr
+				.map((x: { sql?: SQL; value?: any }) => x.value)
+				.filter((x: any) => x !== undefined);
+			if (sqls.length) {
+				pushIf(or(...sqls));
+			}
+			if (values.length) {
+				pushIf(inArray(column, values));
+			}
+		}
+		if ("nin" in v) {
+			const arr = (v.nin ?? []).map((item: any) =>
+				unwrapEscapedValue(column, item)
+			);
+			const sqls = arr
+				.map((x: { sql?: SQL; value?: any }) => x.sql)
+				.filter(Boolean) as SQL[];
+			const values = arr
+				.map((x: { sql?: SQL; value?: any }) => x.value)
+				.filter((x: any) => x !== undefined);
+			if (sqls.length) {
+				pushIf(or(...sqls));
+			}
+			if (values.length) {
+				pushIf(notInArray(column, values));
+			}
+		}
+		if ("isNull" in v) {
+			pushIf(v.isNull ? isNull(column) : undefined);
+		}
+
+		if ("gt" in v) {
+			const u = unwrapEscapedValue(column, v.gt);
+			pushIf(u.sql ?? gt(column, u.value));
+		}
+		if ("gte" in v) {
+			const u = unwrapEscapedValue(column, v.gte);
+			pushIf(u.sql ?? gte(column, u.value));
+		}
+		if ("lt" in v) {
+			const u = unwrapEscapedValue(column, v.lt);
+			pushIf(u.sql ?? lt(column, u.value));
+		}
+		if ("lte" in v) {
+			const u = unwrapEscapedValue(column, v.lte);
+			pushIf(u.sql ?? lte(column, u.value));
+		}
+		if ("between" in v) {
+			const a = unwrapEscapedValue(column, v.between?.[0]);
+			const b = unwrapEscapedValue(column, v.between?.[1]);
+			if (a.sql) {
+				pushIf(a.sql);
+			}
+			if (b.sql) {
+				pushIf(b.sql);
+			}
+			pushIf(between(column, a.value, b.value));
+		}
+		if ("notBetween" in v) {
+			const a = unwrapEscapedValue(column, v.notBetween?.[0]);
+			const b = unwrapEscapedValue(column, v.notBetween?.[1]);
+			if (a.sql) {
+				pushIf(a.sql);
+			}
+			if (b.sql) {
+				pushIf(b.sql);
+			}
+			pushIf(notBetween(column, a.value, b.value));
+		}
+
+		if ("like" in v) {
+			const u = unwrapEscapedValue(column, v.like);
+			pushIf(u.sql ?? like(column, u.value));
+		}
+		if ("ilike" in v) {
+			const u = unwrapEscapedValue(column, v.ilike);
+			pushIf(u.sql ?? ilike(column, u.value));
+		}
+
+		if (Array.isArray(v.or)) {
+			const sub = v.or
+				.map((item: any) => compileColumnValue(column, item))
+				.filter(Boolean) as SQL[];
+			if (sub.length) {
+				pushIf(or(...sub));
+			}
+		}
+
+		if (Array.isArray(v.and)) {
+			const sub = v.and
+				.map((item: any) => compileColumnValue(column, item))
+				.filter(Boolean) as SQL[];
+			if (sub.length) {
+				pushIf(and(...sub));
+			}
+		}
+
+		if (!parts.length) {
+			return undefined;
+		}
+		return parts.length === 1 ? parts[0] : and(...parts);
+	}
+
+	return eq(column, value);
 }
 
-export function compileWhereObject(fields: AnyObj, where: AnyObj): SQL | undefined {
-  const parts: SQL[] = [];
-  for (const [key, value] of Object.entries(where)) {
-    if (value === undefined) continue;
-
-    const col = (fields as any)[key];
-    if (col) {
-      const sql = compileColumnValue(col, value);
-      if (sql) parts.push(sql);
-      continue;
-    }
-
-    if (value && typeof value === "object") {
-      throw new Error(`Relation where is not implemented yet for key '${key}'.`);
-    }
-  }
-
-  if (!parts.length) return undefined;
-  return parts.length === 1 ? parts[0] : and(...parts);
+export function compileWhereObject(
+	fields: AnyObj,
+	where: AnyObj
+): SQL | undefined {
+	const parts: SQL[] = [];
+	for (const [key, value] of Object.entries(where)) {
+		if (value === undefined) {
+			continue;
+		}
+
+		const col = (fields as any)[key];
+		if (col) {
+			const sql = compileColumnValue(col, value);
+			if (sql) {
+				parts.push(sql);
+			}
+			continue;
+		}
+
+		if (value && typeof value === "object") {
+			throw new Error(
+				`Relation where is not implemented yet for key '${key}'.`
+			);
+		}
+	}
+
+	if (!parts.length) {
+		return undefined;
+	}
+	return parts.length === 1 ? parts[0] : and(...parts);
 }
 
 export function compileWhere(fields: AnyObj, where: unknown): SQL | undefined {
-  if (!where) return undefined;
-
-  if (typeof where === "object" && where && !isPromiseLike(where)) {
-    if ((where as any).$model === "model") {
-      throw new Error("Model-as-where is not implemented yet.");
-    }
-    if ((where as any).getSQL) return where as any;
-    return compileWhereObject(fields, where as AnyObj);
-  }
-
-  return where as any;
+	if (!where) {
+		return undefined;
+	}
+
+	if (typeof where === "object" && where && !isPromiseLike(where)) {
+		if ((where as any).$model === "model") {
+			throw new Error("Model-as-where is not implemented yet.");
+		}
+		if ((where as any).getSQL) {
+			return where as any;
+		}
+		return compileWhereObject(fields, where as AnyObj);
+	}
+
+	return where as any;
 }