@apisr/drizzle-model 0.0.4 → 2.0.0

package/src/model/core/runtime.ts

@@ -1,334 +0,0 @@
-import { and } from "drizzle-orm";
-import type { ModelDialect, ReturningIdDialects } from "../dialect.ts";
-import type { MethodWhereValue } from "../methods/query/where.ts";
-import type { MethodUpsertValue } from "../methods/upsert.ts";
-import type { MethodWithValue } from "../methods/with.ts";
-import type { ModelOptions } from "../options.ts";
-import { buildSelectProjection } from "./projection.ts";
-import type { MutateState, QueryState } from "./thenable.ts";
-import { MutateResult, QueryResult } from "./thenable.ts";
-import { applyExclude, applyFormat, applySelect } from "./transform.ts";
-import { compileWhere } from "./where.ts";
-import { runWithJoins } from "./with.ts";
-
-type AnyObj = Record<string, any>;
-
-type MutateKind = "insert" | "update" | "delete" | "upsert";
-
-type BaseState = {
-	db: any;
-	where: unknown;
-};
-
-// TODO: can be broken...
-function compileEffectiveWhere(
-	table: AnyObj,
-	optionsWhere: unknown,
-	stateWhere: unknown
-) {
-	const base = compileWhere(table, optionsWhere);
-	const extra = compileWhere(table, stateWhere);
-	if (base && extra) {
-		return and(base as any, extra as any);
-	}
-	return (base ?? extra) as any;
-}
-
-function isReturningIdDialect(dialect: string): dialect is ReturningIdDialects {
-	return (
-		dialect === "MySQL" ||
-		dialect === "SingleStore" ||
-		dialect === "CockroachDB"
-	);
-}
-
-async function execReturn(
-	q: any,
-	mState: MutateState,
-	dialect: string
-): Promise<any> {
-	if (typeof q?.returning === "function") {
-		return await (mState.returnSelect
-			? q.returning(mState.returnSelect)
-			: q.returning());
-	}
-	if (isReturningIdDialect(dialect) && typeof q?.$returningId === "function") {
-		return await q.$returningId();
-	}
-	return await q;
-}
-
-function normalizeUpsertTarget(table: AnyObj, target: any): any {
-	if (!target) {
-		return target;
-	}
-	if (typeof target === "string") {
-		return (table as any)[target] ?? target;
-	}
-	if (Array.isArray(target)) {
-		return target.map((t) =>
-			typeof t === "string" ? ((table as any)[t] ?? t) : t
-		);
-	}
-	return target;
-}
-
-export function makeModelRuntime(config: {
-	db: any;
-	schema: Record<string, any>;
-	relations: Record<string, any>;
-	tableName: string;
-	dialect: ModelDialect;
-	options: ModelOptions<any, any, any, any>;
-}): any {
-	const baseState: BaseState = {
-		db: config.db,
-		where: undefined as unknown,
-	};
-
-	const build = (state: BaseState): any => {
-		const modelObj: AnyObj = {
-			$model: "model",
-			$modelName: config.tableName,
-			$format: config.options.format,
-			$formatValue: undefined,
-			where(value: MethodWhereValue<any, any>) {
-				return build({ ...state, where: value });
-			},
-			include(value: MethodWithValue<any, any>) {
-				return value;
-			},
-			extend(nextOptions: any) {
-				return makeModelRuntime({
-					...config,
-					options: {
-						...config.options,
-						...nextOptions,
-						methods: {
-							...(nextOptions?.methods ?? {}),
-							...(config.options?.methods ?? {}),
-						},
-						format: nextOptions?.format ?? config.options?.format,
-					},
-				});
-			},
-			db(db: any) {
-				return makeModelRuntime({ ...config, db });
-			},
-		};
-
-		const attachMethods = (methods: AnyObj | undefined) => {
-			if (!methods) {
-				return;
-			}
-			for (const [key, fn] of Object.entries(methods)) {
-				if (typeof fn === "function") {
-					(modelObj as any)[key] = fn.bind(modelObj);
-				}
-			}
-		};
-
-		attachMethods(config.options.methods);
-
-		modelObj.findMany = () => {
-			const runner = async (qState: QueryState) => {
-				const table = (config.schema as any)[config.tableName];
-				const whereSql = compileEffectiveWhere(
-					table as AnyObj,
-					config.options.where,
-					state.where
-				);
-
-				let result: any;
-				if (qState.with) {
-					result = await runWithJoins({
-						db: config.db,
-						schema: config.schema,
-						relations: config.relations,
-						tableName: config.tableName,
-						table,
-						dialect: config.dialect,
-						whereSql,
-						qState,
-						kind: "many",
-					});
-				} else {
-					const { selectMap } = buildSelectProjection(
-						table as AnyObj,
-						qState.select as any,
-						qState.exclude as any
-					);
-					let q = (config.db as any).select(selectMap).from(table);
-					if (whereSql) {
-						q = q.where(whereSql);
-					}
-					result = await q;
-				}
-
-				let out: any = result;
-				if (qState.select) {
-					out = applySelect(out, qState.select);
-				}
-				if (qState.exclude) {
-					out = applyExclude(out, qState.exclude);
-				}
-				if (!qState.raw) {
-					out = applyFormat(out, config.options.format);
-				}
-				return out;
-			};
-
-			return new QueryResult({} as QueryState, runner) as any;
-		};
-
-		modelObj.findFirst = () => {
-			const runner = async (qState: QueryState) => {
-				const table = (config.schema as any)[config.tableName];
-				const whereSql = compileEffectiveWhere(
-					table as AnyObj,
-					config.options.where,
-					state.where
-				);
-
-				let result: any;
-				if (qState.with) {
-					result = await runWithJoins({
-						db: config.db,
-						schema: config.schema,
-						relations: config.relations,
-						tableName: config.tableName,
-						table,
-						dialect: config.dialect,
-						whereSql,
-						qState,
-						kind: "one",
-					});
-				} else {
-					const { selectMap } = buildSelectProjection(
-						table as AnyObj,
-						qState.select as any,
-						qState.exclude as any
-					);
-					let q = (config.db as any).select(selectMap).from(table);
-					if (whereSql) {
-						q = q.where(whereSql);
-					}
-					q = q.limit(1);
-					const rows = await q;
-					result = rows[0];
-				}
-
-				let out: any = result;
-				if (qState.select) {
-					out = applySelect(out, qState.select);
-				}
-				if (qState.exclude) {
-					out = applyExclude(out, qState.exclude);
-				}
-				if (!qState.raw) {
-					out = applyFormat(out, config.options.format);
-				}
-				return out;
-			};
-
-			return new QueryResult({} as QueryState, runner) as any;
-		};
-
-		modelObj.insert = (value: any) => {
-			const runner = async (mState: MutateState) => {
-				const table = (config.schema as any)[config.tableName];
-				const q = (config.db as any).insert(table).values(mState.value);
-				const result = await execReturn(q, mState, config.dialect);
-				if (!Array.isArray(mState.value) && Array.isArray(result)) {
-					return result[0];
-				}
-				return result;
-			};
-
-			return new MutateResult(
-				{ kind: "insert" as MutateKind, value } as MutateState,
-				runner
-			) as any;
-		};
-
-		modelObj.update = (value: any) => {
-			const runner = async (mState: MutateState) => {
-				const table = (config.schema as any)[config.tableName];
-				const whereSql = compileEffectiveWhere(
-					table as AnyObj,
-					config.options.where,
-					state.where
-				);
-				let q = (config.db as any).update(table).set(mState.value);
-				if (whereSql) {
-					q = q.where(whereSql);
-				}
-				return await execReturn(q, mState, config.dialect);
-			};
-
-			return new MutateResult(
-				{ kind: "update" as MutateKind, value } as MutateState,
-				runner
-			) as any;
-		};
-
-		modelObj.delete = () => {
-			const runner = async (mState: MutateState) => {
-				const table = (config.schema as any)[config.tableName];
-				const whereSql = compileEffectiveWhere(
-					table as AnyObj,
-					config.options.where,
-					state.where
-				);
-				let q = (config.db as any).delete(table);
-				if (whereSql) {
-					q = q.where(whereSql);
-				}
-				return await execReturn(q, mState, config.dialect);
-			};
-
-			return new MutateResult(
-				{ kind: "delete" as MutateKind } as MutateState,
-				runner
-			) as any;
-		};
-
-		modelObj.upsert = (value: MethodUpsertValue<any>) => {
-			const runner = async (mState: MutateState) => {
-				const table = (config.schema as any)[config.tableName];
-				const insertValues = (mState.value as any).insert;
-				const updateCfg = (mState.value as any).update;
-				const target = normalizeUpsertTarget(
-					table as AnyObj,
-					(mState.value as any).target
-				);
-				let updateSet = updateCfg;
-				if (typeof updateCfg === "function") {
-					updateSet = updateCfg({
-						excluded: (field: string) => (table as any)[field],
-						inserted: (field: string) => (table as any)[field],
-					});
-				}
-
-				let q = (config.db as any).insert(table).values(insertValues);
-				if (q.onConflictDoUpdate) {
-					q = q.onConflictDoUpdate({
-						target,
-						set: updateSet,
-					});
-				}
-
-				return await execReturn(q, mState, config.dialect);
-			};
-
-			return new MutateResult(
-				{ kind: "upsert" as MutateKind, value } as MutateState,
-				runner
-			) as any;
-		};
-
-		return modelObj;
-	};
-
-	return build(baseState);
-}

package/src/model/core/thenable.ts

@@ -1,94 +0,0 @@
-import type { MethodExcludeValue } from "../methods/exclude.ts";
-import type { MethodSelectValue } from "../methods/select.ts";
-import type { MethodWithValue } from "../methods/with.ts";
-
-type AnyObj = Record<string, any>;
-
-type QueryState = {
-	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;
-};
-
-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);
-	}
-}
-
-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;
-	}
-}
-
-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;
-	}
-}
-
-export type { QueryState, MutateState, MutateKind };

package/src/model/core/transform.ts

@@ -1,65 +0,0 @@
-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;
-	}
-
-	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;
-	}
-
-	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);
-}