@apisr/drizzle-model 2.0.2 → 2.0.4

package/dist/model/core/runtime.mjs

@@ -1,198 +0,0 @@
-import { buildSelectProjection } from "./projection.mjs";
-import { MutateResult, QueryResult } from "./thenable.mjs";
-import { applyExclude, applyFormat, applySelect } from "./transform.mjs";
-import { compileWhere } from "./where.mjs";
-import { runWithJoins } from "./with.mjs";
-import { and } from "drizzle-orm";
-
-//#region src/model/core/runtime.ts
-function compileEffectiveWhere(table, optionsWhere, stateWhere) {
-	const base = compileWhere(table, optionsWhere);
-	const extra = compileWhere(table, stateWhere);
-	if (base && extra) return and(base, extra);
-	return base ?? extra;
-}
-function isReturningIdDialect(dialect) {
-	return dialect === "MySQL" || dialect === "SingleStore" || dialect === "CockroachDB";
-}
-async function execReturn(q, mState, dialect) {
-	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, target) {
-	if (!target) return target;
-	if (typeof target === "string") return table[target] ?? target;
-	if (Array.isArray(target)) return target.map((t) => typeof t === "string" ? table[t] ?? t : t);
-	return target;
-}
-function makeModelRuntime(config) {
-	const baseState = {
-		db: config.db,
-		where: void 0
-	};
-	const build = (state) => {
-		const modelObj = {
-			$model: "model",
-			$modelName: config.tableName,
-			$format: config.options.format,
-			$formatValue: void 0,
-			where(value) {
-				return build({
-					...state,
-					where: value
-				});
-			},
-			include(value) {
-				return value;
-			},
-			extend(nextOptions) {
-				return makeModelRuntime({
-					...config,
-					options: {
-						...config.options,
-						...nextOptions,
-						methods: {
-							...nextOptions?.methods ?? {},
-							...config.options?.methods ?? {}
-						},
-						format: nextOptions?.format ?? config.options?.format
-					}
-				});
-			},
-			db(db) {
-				return makeModelRuntime({
-					...config,
-					db
-				});
-			}
-		};
-		const attachMethods = (methods) => {
-			if (!methods) return;
-			for (const [key, fn] of Object.entries(methods)) if (typeof fn === "function") modelObj[key] = fn.bind(modelObj);
-		};
-		attachMethods(config.options.methods);
-		modelObj.findMany = () => {
-			const runner = async (qState) => {
-				const table = config.schema[config.tableName];
-				const whereSql = compileEffectiveWhere(table, config.options.where, state.where);
-				let result;
-				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, qState.select, qState.exclude);
-					let q = config.db.select(selectMap).from(table);
-					if (whereSql) q = q.where(whereSql);
-					result = await q;
-				}
-				let out = 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({}, runner);
-		};
-		modelObj.findFirst = () => {
-			const runner = async (qState) => {
-				const table = config.schema[config.tableName];
-				const whereSql = compileEffectiveWhere(table, config.options.where, state.where);
-				let result;
-				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, qState.select, qState.exclude);
-					let q = config.db.select(selectMap).from(table);
-					if (whereSql) q = q.where(whereSql);
-					q = q.limit(1);
-					result = (await q)[0];
-				}
-				let out = 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({}, runner);
-		};
-		modelObj.insert = (value) => {
-			const runner = async (mState) => {
-				const table = config.schema[config.tableName];
-				return await execReturn(config.db.insert(table).values(mState.value), mState, config.dialect);
-			};
-			return new MutateResult({
-				kind: "insert",
-				value
-			}, runner);
-		};
-		modelObj.update = (value) => {
-			const runner = async (mState) => {
-				const table = config.schema[config.tableName];
-				const whereSql = compileEffectiveWhere(table, config.options.where, state.where);
-				let q = config.db.update(table).set(mState.value);
-				if (whereSql) q = q.where(whereSql);
-				return await execReturn(q, mState, config.dialect);
-			};
-			return new MutateResult({
-				kind: "update",
-				value
-			}, runner);
-		};
-		modelObj.delete = () => {
-			const runner = async (mState) => {
-				const table = config.schema[config.tableName];
-				const whereSql = compileEffectiveWhere(table, config.options.where, state.where);
-				let q = config.db.delete(table);
-				if (whereSql) q = q.where(whereSql);
-				return await execReturn(q, mState, config.dialect);
-			};
-			return new MutateResult({ kind: "delete" }, runner);
-		};
-		modelObj.upsert = (value) => {
-			const runner = async (mState) => {
-				const table = config.schema[config.tableName];
-				const insertValues = mState.value.insert;
-				const updateCfg = mState.value.update;
-				const target = normalizeUpsertTarget(table, mState.value.target);
-				let updateSet = updateCfg;
-				if (typeof updateCfg === "function") updateSet = updateCfg({
-					excluded: (field) => table[field],
-					inserted: (field) => table[field]
-				});
-				let q = config.db.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",
-				value
-			}, runner);
-		};
-		return modelObj;
-	};
-	return build(baseState);
-}
-
-//#endregion
-export { makeModelRuntime };

package/dist/model/core/thenable.mjs

@@ -1,64 +0,0 @@
-//#region src/model/core/thenable.ts
-var ThenableResult = class {
-	_execute;
-	constructor(execute) {
-		this._execute = execute;
-	}
-	then(onfulfilled, onrejected) {
-		return this._execute().then(onfulfilled, onrejected);
-	}
-};
-var QueryResult = class QueryResult extends ThenableResult {
-	state;
-	runner;
-	constructor(state, runner) {
-		super(() => runner(state));
-		this.state = state;
-		this.runner = runner;
-	}
-	with(value) {
-		return new QueryResult({
-			...this.state,
-			with: value
-		}, this.runner);
-	}
-	select(value) {
-		return new QueryResult({
-			...this.state,
-			select: value
-		}, this.runner);
-	}
-	exclude(value) {
-		return new QueryResult({
-			...this.state,
-			exclude: value
-		}, this.runner);
-	}
-	raw() {
-		return new QueryResult({
-			...this.state,
-			raw: true
-		}, this.runner);
-	}
-	debug() {
-		return this.state;
-	}
-};
-var MutateResult = class MutateResult extends ThenableResult {
-	state;
-	runner;
-	constructor(state, runner) {
-		super(() => runner(state));
-		this.state = state;
-		this.runner = runner;
-	}
-	return(value) {
-		return new MutateResult({
-			...this.state,
-			returnSelect: value
-		}, this.runner);
-	}
-};
-
-//#endregion
-export { MutateResult, QueryResult };

package/dist/model/core/transform.mjs

@@ -1,39 +0,0 @@
-//#region src/model/core/transform.ts
-function applySelect(value, select) {
-	if (value == null) return value;
-	if (Array.isArray(value)) return value.map((v) => applySelect(v, select));
-	if (typeof value !== "object") return value;
-	const out = {};
-	for (const [key, sel] of Object.entries(select)) {
-		if (sel === true) {
-			out[key] = value[key];
-			continue;
-		}
-		if (sel && typeof sel === "object") out[key] = applySelect(value[key], sel);
-	}
-	return out;
-}
-function applyExclude(value, exclude) {
-	if (value == null) return value;
-	if (Array.isArray(value)) return value.map((v) => applyExclude(v, exclude));
-	if (typeof value !== "object") return value;
-	const out = { ...value };
-	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);
-	}
-	return out;
-}
-function applyFormat(value, format) {
-	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);
-}
-
-//#endregion
-export { applyExclude, applyFormat, applySelect };

package/dist/model/core/where.mjs

@@ -1,130 +0,0 @@
-import { and, between, eq, gt, gte, ilike, inArray, isNull, like, lt, lte, ne, notBetween, notInArray, or } from "drizzle-orm";
-
-//#region src/model/core/where.ts
-function isPromiseLike(value) {
-	return value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
-}
-function isEscapedValue(value) {
-	return value && typeof value === "object" && ("equal" in value || value.__kind === "esc-op");
-}
-function unwrapEscapedValue(column, value) {
-	if (!isEscapedValue(value)) return { value };
-	if (value.__kind === "esc-op") return { sql: value.op(column, value.value) };
-	return { value: value.equal };
-}
-function compileColumnValue(column, value) {
-	if (isEscapedValue(value)) {
-		if (value.__kind === "esc-op") return value.op(column, value.value);
-		return eq(column, value.equal);
-	}
-	if (value && typeof value === "object" && !Array.isArray(value)) {
-		const parts = [];
-		const pushIf = (sql) => {
-			if (sql) parts.push(sql);
-		};
-		const v = 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) => unwrapEscapedValue(column, item));
-			const sqls = arr.map((x) => x.sql).filter(Boolean);
-			const values = arr.map((x) => x.value).filter((x) => x !== void 0);
-			if (sqls.length) pushIf(or(...sqls));
-			if (values.length) pushIf(inArray(column, values));
-		}
-		if ("nin" in v) {
-			const arr = (v.nin ?? []).map((item) => unwrapEscapedValue(column, item));
-			const sqls = arr.map((x) => x.sql).filter(Boolean);
-			const values = arr.map((x) => x.value).filter((x) => x !== void 0);
-			if (sqls.length) pushIf(or(...sqls));
-			if (values.length) pushIf(notInArray(column, values));
-		}
-		if ("isNull" in v) pushIf(v.isNull ? isNull(column) : void 0);
-		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) => compileColumnValue(column, item)).filter(Boolean);
-			if (sub.length) pushIf(or(...sub));
-		}
-		if (Array.isArray(v.and)) {
-			const sub = v.and.map((item) => compileColumnValue(column, item)).filter(Boolean);
-			if (sub.length) pushIf(and(...sub));
-		}
-		if (!parts.length) return;
-		return parts.length === 1 ? parts[0] : and(...parts);
-	}
-	return eq(column, value);
-}
-function compileWhereObject(fields, where) {
-	const parts = [];
-	for (const [key, value] of Object.entries(where)) {
-		if (value === void 0) continue;
-		const col = fields[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;
-	return parts.length === 1 ? parts[0] : and(...parts);
-}
-function compileWhere(fields, where) {
-	if (!where) return;
-	if (typeof where === "object" && where && !isPromiseLike(where)) {
-		if (where.$model === "model") throw new Error("Model-as-where is not implemented yet.");
-		if (where.getSQL) return where;
-		return compileWhereObject(fields, where);
-	}
-	return where;
-}
-
-//#endregion
-export { compileWhere };

package/dist/model/core/with.mjs

@@ -1,19 +0,0 @@
-import { executeWithJoins } from "./joins.mjs";
-
-//#region src/model/core/with.ts
-async function runWithJoins(args) {
-	return await executeWithJoins({
-		db: args.db,
-		schema: args.schema,
-		relations: args.relations,
-		baseTableName: args.tableName,
-		baseTable: args.table,
-		dialect: args.dialect,
-		whereSql: args.whereSql,
-		withValue: args.qState.with,
-		limitOne: args.kind === "one"
-	});
-}
-
-//#endregion
-export { runWithJoins };