@apisr/drizzle-model 2.0.2 → 2.0.3

package/dist/model/core/joins.mjs

@@ -1,184 +0,0 @@
-import { and, eq } from "drizzle-orm";
-
-//#region src/model/core/joins.ts
-function isDrizzleColumn(value) {
-	return !!value && typeof value === "object" && typeof value.getSQL === "function";
-}
-function getPrimaryKeyField(table) {
-	for (const [k, v] of Object.entries(table)) {
-		if (!isDrizzleColumn(v)) continue;
-		if (v.primary === true) return k;
-		if (v.config?.primaryKey === true) return k;
-	}
-	if ("id" in table) return "id";
-	return Object.keys(table).find((k) => isDrizzleColumn(table[k])) ?? "id";
-}
-function isAllNullRow(obj) {
-	if (!obj || typeof obj !== "object") return true;
-	for (const v of Object.values(obj)) if (v !== null && v !== void 0) return false;
-	return true;
-}
-async function aliasTable(table, aliasName, dialect) {
-	if (dialect === "PostgreSQL") {
-		const mod = await import("drizzle-orm/pg-core");
-		if (typeof mod.alias === "function") return mod.alias(table, aliasName);
-	}
-	if (dialect === "MySQL") {
-		const mod = await import("drizzle-orm/mysql-core");
-		if (typeof mod.alias === "function") return mod.alias(table, aliasName);
-	}
-	if (dialect === "SQLite") {
-		const mod = await import("drizzle-orm/sqlite-core");
-		if (typeof mod.alias === "function") return mod.alias(table, aliasName);
-	}
-	return table;
-}
-function buildJoinOn(node) {
-	const parts = node.sourceColumns.map((src, i) => {
-		const tgt = node.targetColumns[i];
-		const tgtKey = Object.entries(node.targetTable).find(([, v]) => v === tgt)?.[0];
-		return eq(tgtKey ? node.targetAliasTable[tgtKey] : tgt, src);
-	});
-	return parts.length === 1 ? parts[0] : and(...parts);
-}
-function buildSelectMapForTable(table) {
-	const out = {};
-	for (const [k, v] of Object.entries(table)) if (isDrizzleColumn(v)) out[k] = v;
-	return out;
-}
-async function executeWithJoins(args) {
-	const { db, schema, relations, baseTableName, baseTable, dialect, whereSql, withValue, limitOne } = args;
-	const usedAliasKeys = /* @__PURE__ */ new Set();
-	const buildNode = async (parent, currentTableName, currentTable, key, value, path) => {
-		const relMeta = relations[currentTableName]?.relations?.[key];
-		if (!relMeta) throw new Error(`Unknown relation '${key}' on table '${currentTableName}'.`);
-		const targetTableName = relMeta.targetTableName;
-		const targetTable = schema[targetTableName];
-		const aliasKeyBase = [...path, key].join("__");
-		let aliasKey = aliasKeyBase;
-		let idx = 1;
-		while (usedAliasKeys.has(aliasKey)) aliasKey = `${aliasKeyBase}_${idx++}`;
-		usedAliasKeys.add(aliasKey);
-		const needsAlias = targetTableName === currentTableName || usedAliasKeys.has(`table:${targetTableName}`);
-		usedAliasKeys.add(`table:${targetTableName}`);
-		const targetAliasTable = needsAlias ? await aliasTable(targetTable, aliasKey, dialect) : targetTable;
-		const node = {
-			path: [...path, key],
-			key,
-			relationType: relMeta.relationType,
-			sourceTableName: currentTableName,
-			targetTableName,
-			sourceTable: currentTable,
-			targetTable,
-			targetAliasTable,
-			aliasKey,
-			sourceColumns: relMeta.sourceColumns ?? [],
-			targetColumns: relMeta.targetColumns ?? [],
-			pkField: getPrimaryKeyField(targetAliasTable),
-			parent,
-			children: []
-		};
-		if (value && typeof value === "object" && value !== true) for (const [childKey, childVal] of Object.entries(value)) {
-			if (childVal !== true && (typeof childVal !== "object" || childVal == null)) continue;
-			const child = await buildNode(node, targetTableName, targetAliasTable, childKey, childVal, [...path, key]);
-			node.children.push(child);
-		}
-		return node;
-	};
-	const root = {
-		path: [],
-		key: "$root",
-		relationType: "one",
-		sourceTableName: baseTableName,
-		targetTableName: baseTableName,
-		sourceTable: baseTable,
-		targetTable: baseTable,
-		targetAliasTable: baseTable,
-		aliasKey: "$base",
-		sourceColumns: [],
-		targetColumns: [],
-		pkField: getPrimaryKeyField(baseTable),
-		children: []
-	};
-	for (const [key, value] of Object.entries(withValue)) {
-		if (value !== true && (typeof value !== "object" || value == null)) continue;
-		const child = await buildNode(void 0, baseTableName, baseTable, key, value, []);
-		root.children.push(child);
-	}
-	const nodes = [];
-	const walk = (n) => {
-		for (const c of n.children) {
-			nodes.push(c);
-			walk(c);
-		}
-	};
-	walk(root);
-	const selectMap = { base: buildSelectMapForTable(baseTable) };
-	for (const n of nodes) selectMap[n.aliasKey] = buildSelectMapForTable(n.targetAliasTable);
-	let q = db.select(selectMap).from(baseTable);
-	if (whereSql) q = q.where(whereSql);
-	for (const n of nodes) {
-		const on = buildJoinOn(n);
-		q = q.leftJoin(n.targetAliasTable, on);
-	}
-	if (limitOne) q = q.limit(1);
-	const rows = await q;
-	const basePk = root.pkField;
-	const baseMap = /* @__PURE__ */ new Map();
-	const ensureManyContainer = (obj, key) => {
-		if (!Array.isArray(obj[key])) obj[key] = [];
-	};
-	const ensureOneContainer = (obj, key) => {
-		if (!(key in obj)) obj[key] = null;
-	};
-	const manyIndexByPath = /* @__PURE__ */ new Map();
-	for (const row of rows) {
-		const baseRow = row.base;
-		const baseId = baseRow[basePk];
-		if (baseId === void 0) continue;
-		const baseObj = (() => {
-			const existing = baseMap.get(baseId);
-			if (existing) return existing;
-			const created = { ...baseRow };
-			baseMap.set(baseId, created);
-			return created;
-		})();
-		for (const n of nodes) {
-			const data = row[n.aliasKey];
-			const relPath = n.path.join(".");
-			const parentPath = n.parent ? n.parent.path.join(".") : "";
-			let parentObj = baseObj;
-			if (parentPath) {
-				const parentIndex = manyIndexByPath.get(parentPath);
-				if (parentIndex && parentIndex.size) parentObj = Array.from(parentIndex.values()).at(-1);
-				else {
-					const parentKey = n.parent?.key;
-					parentObj = parentKey ? baseObj[parentKey] ?? baseObj : baseObj;
-				}
-			}
-			if (isAllNullRow(data)) {
-				if (n.relationType === "one") ensureOneContainer(parentObj, n.key);
-				else ensureManyContainer(parentObj, n.key);
-				continue;
-			}
-			const pk = data[n.pkField];
-			if (n.relationType === "one") parentObj[n.key] = { ...data };
-			else {
-				ensureManyContainer(parentObj, n.key);
-				const indexKey = relPath;
-				if (!manyIndexByPath.has(indexKey)) manyIndexByPath.set(indexKey, /* @__PURE__ */ new Map());
-				const idxMap = manyIndexByPath.get(indexKey);
-				if (!idxMap.has(pk)) {
-					const obj = { ...data };
-					idxMap.set(pk, obj);
-					parentObj[n.key].push(obj);
-				}
-			}
-		}
-	}
-	const out = Array.from(baseMap.values());
-	return limitOne ? out[0] : out;
-}
-
-//#endregion
-export { executeWithJoins };

package/dist/model/core/projection.mjs

@@ -1,28 +0,0 @@
-//#region src/model/core/projection.ts
-function isDrizzleColumn(value) {
-	return !!value && typeof value === "object" && typeof value.getSQL === "function";
-}
-function getTableColumnsMap(table) {
-	const out = {};
-	for (const [key, value] of Object.entries(table)) if (isDrizzleColumn(value)) out[key] = value;
-	return out;
-}
-function buildSelectProjection(table, select, exclude) {
-	const all = getTableColumnsMap(table);
-	if (select && typeof select === "object") {
-		const picked = {};
-		for (const [key, value] of Object.entries(select)) if (value === true && key in all) picked[key] = all[key];
-		if (Object.keys(picked).length) return { selectMap: picked };
-		return { selectMap: all };
-	}
-	if (exclude && typeof exclude === "object") {
-		const omitted = { ...all };
-		for (const [key, value] of Object.entries(exclude)) if (value === true) delete omitted[key];
-		if (Object.keys(omitted).length) return { selectMap: omitted };
-		return { selectMap: all };
-	}
-	return { selectMap: all };
-}
-
-//#endregion
-export { buildSelectProjection };

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 };