appflare 0.0.28 → 0.1.1

package/server/database/context.ts

@@ -1,327 +0,0 @@
-import type { Collection, Document } from "mongodb";
-import { ObjectId } from "mongodb";
-import { createPatchBuilder, createUpdateBuilder } from "./builders";
-import { createQueryBuilder } from "./query-builder";
-import {
-	isIdValue,
-	normalizeIdFilter,
-	normalizeRefFields,
-	toMongoFilter,
-} from "../utils/id-utils";
-import { buildSchemaRefMap } from "../types/schema-refs";
-import type {
-	CreateMongoDbContextOptions,
-	MongoDbCoreContext,
-	MongoDbContext,
-	MongoDbQuery,
-	AppflareTableClient,
-	TableDocBase,
-} from "../types/types";
-
-export function createMongoDbContext<
-	TTableNames extends string,
-	TTableDocMap extends Record<TTableNames, TableDocBase>,
->(
-	options: CreateMongoDbContextOptions<TTableNames>
-): MongoDbContext<TTableNames, TTableDocMap> {
-	const collectionName = options.collectionName ?? ((t) => t);
-	const collections = new Map<string, Collection<Document>>();
-	const refs = buildSchemaRefMap(options.schema);
-	const tableNames = Object.keys(options.schema) as TTableNames[];
-
-	const getCollection = (table: string): Collection<Document> => {
-		const key = collectionName(table as any);
-		const existing = collections.get(key);
-		if (existing) return existing;
-		const created = options.db.collection(key);
-		collections.set(key, created);
-		return created;
-	};
-
-	const core: MongoDbCoreContext<TTableNames, TTableDocMap> = {
-		query: (table) =>
-			createQueryBuilder<TTableNames, TTableDocMap, any>({
-				table: table as any,
-				getCollection,
-				refs,
-			}),
-		insert: async (table, value) => {
-			const coll = getCollection(table as string);
-			const objectId = new ObjectId();
-			const normalized = normalizeRefFields(
-				table as string,
-				value as Record<string, unknown>,
-				refs
-			);
-			const doc = {
-				...normalized,
-				_id: objectId,
-				_creationTime: Date.now(),
-			} as unknown as Document;
-
-			await coll.insertOne(doc);
-			return objectId.toHexString() as any;
-		},
-		update: ((table: any, where?: any, partial?: any) => {
-			const coll = getCollection(table as string);
-			const filter = normalizeIdFilter(toMongoFilter(where));
-			const update = {
-				$set: normalizeRefFields(table as string, partial as any, refs) as any,
-			};
-			if (isIdValue(where)) {
-				return coll.updateOne(filter, update).then(() => {});
-			}
-			return coll.updateMany(filter, update).then(() => {});
-		}) as any,
-		patch: ((table: any, where?: any, partial?: any) => {
-			const coll = getCollection(table as string);
-			const filter = normalizeIdFilter(toMongoFilter(where));
-			const update = {
-				$set: normalizeRefFields(table as string, partial as any, refs) as any,
-			};
-			if (isIdValue(where)) {
-				return coll.updateOne(filter, update).then(() => {});
-			}
-			return coll.updateMany(filter, update).then(() => {});
-		}) as any,
-		delete: ((table: any, where?: any) => {
-			const coll = getCollection(table as string);
-			const filter = normalizeIdFilter(toMongoFilter(where));
-			if (isIdValue(where)) {
-				return coll.deleteOne(filter).then(() => {});
-			}
-			return coll.deleteMany(filter).then(() => {});
-		}) as any,
-	};
-
-	const ctx = {} as MongoDbContext<TTableNames, TTableDocMap>;
-
-	for (const table of tableNames) {
-		(ctx as any)[table] = createAppflareTableClient({
-			table: table as TTableNames,
-			core,
-			refs,
-			getCollection,
-		});
-	}
-
-	return ctx;
-}
-
-function toKeyList(arg: unknown): string[] | undefined {
-	if (!arg) return undefined;
-	if (typeof arg === "string" || typeof arg === "number") return [String(arg)];
-	if (Array.isArray(arg)) return arg.map((k) => String(k));
-	if (typeof arg === "object") {
-		return Object.entries(arg as Record<string, unknown>)
-			.filter(([, v]) => Boolean(v))
-			.map(([k]) => k);
-	}
-	return undefined;
-}
-
-function createAppflareTableClient<
-	TTableNames extends string,
-	TTableDocMap extends Record<TTableNames, TableDocBase>,
-	TableName extends TTableNames,
->(params: {
-	table: TableName;
-	core: MongoDbCoreContext<TTableNames, TTableDocMap>;
-	refs: ReturnType<typeof buildSchemaRefMap>;
-	getCollection: (table: string) => Collection<Document>;
-}): AppflareTableClient<TableName, TTableDocMap> {
-	const selectKeys = (select: unknown) => toKeyList(select);
-
-	const toArray = <T>(value: T | T[] | undefined): T[] => {
-		if (value === undefined) return [];
-		return Array.isArray(value) ? value : [value];
-	};
-
-	const stringifyAggregateValue = (value: unknown): unknown => {
-		if (value instanceof ObjectId) return value.toHexString();
-		if (Array.isArray(value)) return value.map(stringifyAggregateValue);
-		if (value && typeof value === "object") {
-			const out: Record<string, unknown> = {};
-			for (const [key, val] of Object.entries(
-				value as Record<string, unknown>
-			)) {
-				out[key] = stringifyAggregateValue(val);
-			}
-			return out;
-		}
-		return value;
-	};
-
-	const buildQuery = (args?: {
-		where?: any;
-		orderBy?: any;
-		skip?: number;
-		take?: number;
-		select?: unknown;
-		include?: unknown;
-	}) => {
-		let q: MongoDbQuery<TableName, TTableDocMap, any> = params.core.query(
-			params.table as any
-		) as any;
-		if (args?.where) q = q.where(args.where as any);
-		if (args?.orderBy) q = q.sort(args.orderBy as any);
-		if (args?.skip !== undefined) q = q.offset(args.skip);
-		if (args?.take !== undefined) q = q.limit(args.take);
-		const s = selectKeys(args?.select);
-		if (s?.length) q = q.select(s as any);
-		if (args?.include) q = q.populate(args.include as any);
-		return q;
-	};
-
-	const fetchOne = async (args: {
-		where: any;
-		select?: unknown;
-		include?: unknown;
-	}) => {
-		const q = buildQuery({ ...args, take: 1 });
-		return q.findOne();
-	};
-
-	return {
-		findMany: async (args) => buildQuery(args as any).find() as any,
-		findFirst: async (args) =>
-			buildQuery({
-				...(args as any),
-				take: (args as any)?.take ?? 1,
-			}).findOne() as any,
-		findUnique: async (args) => {
-			if (!args?.where) throw new Error("findUnique requires a where clause");
-			return fetchOne(args as any) as any;
-		},
-		create: async (args) => {
-			const id = await params.core.insert(
-				params.table as any,
-				args.data as any
-			);
-			const created = await fetchOne({
-				where: { _id: id } as any,
-				select: (args as any)?.select,
-				include: (args as any)?.include,
-			});
-			return (created ?? {
-				_id: id,
-				_creationTime: Date.now(),
-				...args.data,
-			}) as any;
-		},
-		update: async (args) => {
-			await params.core.update(
-				params.table as any,
-				args.where as any,
-				args.data as any
-			);
-			return fetchOne({
-				where: args.where as any,
-				select: (args as any)?.select,
-				include: (args as any)?.include,
-			}) as any;
-		},
-		updateMany: async (args) => {
-			const coll = params.getCollection(params.table as string);
-			const filter = normalizeIdFilter(toMongoFilter(args.where ?? {}));
-			const normalized = normalizeRefFields(
-				params.table as string,
-				args.data as any,
-				params.refs
-			);
-			const result = await coll.updateMany(filter as any, {
-				$set: normalized as any,
-			});
-			return { count: result.modifiedCount ?? 0 };
-		},
-		delete: async (args) => {
-			const existing = await fetchOne({
-				where: args.where as any,
-				select: (args as any)?.select,
-				include: (args as any)?.include,
-			});
-			await params.core.delete(params.table as any, args.where as any);
-			return existing as any;
-		},
-		deleteMany: async (args) => {
-			const coll = params.getCollection(params.table as string);
-			const filter = normalizeIdFilter(toMongoFilter(args?.where ?? {}));
-			const result = await coll.deleteMany(filter as any);
-			return { count: result.deletedCount ?? 0 };
-		},
-		count: async (args) => {
-			const coll = params.getCollection(params.table as string);
-			const filter = normalizeIdFilter(toMongoFilter(args?.where ?? {}));
-			return coll.countDocuments(filter ?? {});
-		},
-		aggregate: async (args) => {
-			const coll = params.getCollection(params.table as string);
-			const pipeline: Document[] = [];
-
-			const normalizedWhere = args.where
-				? normalizeIdFilter(
-						toMongoFilter(
-							normalizeRefFields(
-								params.table as string,
-								args.where as Record<string, unknown>,
-								params.refs
-							) as any
-						)
-					)
-				: undefined;
-			if (normalizedWhere && Object.keys(normalizedWhere).length > 0) {
-				pipeline.push({ $match: normalizedWhere });
-			}
-
-			const sumFields = toArray(args.sum).filter(Boolean) as string[];
-			const avgFields = toArray(args.avg).filter(Boolean) as string[];
-			if (sumFields.length === 0 && avgFields.length === 0) {
-				throw new Error("aggregate requires at least one sum or avg field");
-			}
-
-			const groupKeys = toArray(args.groupBy).filter(Boolean) as string[];
-			const groupId =
-				groupKeys.length === 0
-					? null
-					: groupKeys.length === 1
-						? `$${groupKeys[0]}`
-						: Object.fromEntries(groupKeys.map((k) => [k, `$${k}`]));
-
-			const groupStage: Record<string, unknown> = { _id: groupId };
-			for (const field of sumFields) {
-				groupStage[`sum_${field}`] = { $sum: `$${field}` };
-			}
-			for (const field of avgFields) {
-				groupStage[`avg_${field}`] = { $avg: `$${field}` };
-			}
-			pipeline.push({ $group: groupStage });
-
-			const tableRefs = params.refs.get(params.table as string) ?? new Map();
-			const populateKeys = toKeyList(args.populate) ?? [];
-			for (const key of populateKeys) {
-				if (!groupKeys.includes(key)) continue;
-				const target = tableRefs.get(key);
-				if (!target) continue;
-				const useRootId = groupKeys.length === 1 && groupKeys[0] === key;
-				const localField = useRootId ? "_id" : `_id.${key}`;
-				pipeline.push({
-					$lookup: {
-						from: target,
-						localField,
-						foreignField: "_id",
-						as: key,
-					},
-				});
-				pipeline.push({
-					$unwind: {
-						path: `$${key}`,
-						preserveNullAndEmptyArrays: true,
-					},
-				});
-			}
-
-			const results = await coll.aggregate(pipeline as any).toArray();
-			return results.map((doc) => stringifyAggregateValue(doc)) as any;
-		},
-	};
-}

package/server/database/populate.ts

@@ -1,234 +0,0 @@
-import type { Collection, Document } from "mongodb";
-import { ObjectId } from "mongodb";
-import { normalizeIdValue, stringifyIdField } from "../utils/id-utils";
-import type { SchemaRefMap } from "../types/types";
-
-export async function applyPopulate(params: {
-	docs: Array<Record<string, unknown>>;
-	currentTable: string;
-	populateKeys: string[];
-	aggregate?: Record<
-		string,
-		{ count?: boolean; sum?: string[]; avg?: string[] }
-	>;
-	includeDocs?: Record<string, boolean>;
-	selectedKeys: string[] | undefined;
-	refs: SchemaRefMap;
-	getCollection: (table: string) => Collection<Document>;
-}) {
-	const tableRefs = params.refs.get(params.currentTable) ?? new Map();
-	const aggregateConfig = params.aggregate ?? {};
-	const includeDocsConfig = params.includeDocs ?? {};
-
-	const ensureStringId = (val: unknown): string | null => {
-		if (!val) return null;
-		if (typeof val === "string") return val;
-		if (val instanceof ObjectId) return val.toHexString();
-		if (typeof val === "object" && "_id" in (val as any)) {
-			const maybeId = (val as any)._id;
-			if (typeof maybeId === "string") return maybeId;
-			if (maybeId instanceof ObjectId) return maybeId.toHexString();
-		}
-		return null;
-	};
-
-	const docIds = params.docs
-		.map((doc) => {
-			const id = ensureStringId(doc._id);
-			return id ? normalizeIdValue(id) : null;
-		})
-		.filter((v): v is string | ObjectId => Boolean(v));
-
-	if (docIds.length === 0) return;
-
-	// Build reverse ref lookup so populate can work even when the current table
-	// doesn't store the forward reference (e.g., populate tickets on users by
-	// matching tickets.user -> users._id).
-	const reverseRefs = new Map<string, { table: string; field: string }[]>();
-	for (const [table, refs] of params.refs.entries()) {
-		for (const [field, refTable] of refs.entries()) {
-			const list = reverseRefs.get(refTable) ?? [];
-			list.push({ table, field });
-			reverseRefs.set(refTable, list);
-		}
-	}
-
-	const buildLookupMap = (rows: Array<Record<string, unknown>>) => {
-		const byId = new Map<string, Record<string, unknown>[]>();
-		for (const row of rows) {
-			const id = ensureStringId(row._id);
-			if (!id) continue;
-			const items = Array.isArray((row as any).__pop)
-				? ((row as any).__pop as Array<Record<string, unknown>>)
-				: [];
-			items.forEach(stringifyIdField);
-			byId.set(id, items);
-		}
-		return byId;
-	};
-
-	const computeAggregates = (
-		value: unknown,
-		spec: { count?: boolean; sum?: string[]; avg?: string[] }
-	): Record<string, number> | null => {
-		const items = Array.isArray(value)
-			? value
-			: value === undefined || value === null
-				? []
-				: [value];
-
-		const out: Record<string, number> = {};
-		const numericSum = (field: string) => {
-			let total = 0;
-			let found = 0;
-			for (const item of items) {
-				if (!item || typeof item !== "object") continue;
-				const raw = (item as Record<string, unknown>)[field];
-				if (typeof raw === "number" || typeof raw === "bigint") {
-					total += Number(raw);
-					found += 1;
-				}
-			}
-			return { total, found };
-		};
-
-		if (spec.count) out.count = items.length;
-
-		for (const field of spec.sum ?? []) {
-			const { total, found } = numericSum(String(field));
-			if (found > 0) out[`sum_${String(field)}`] = total;
-		}
-
-		for (const field of spec.avg ?? []) {
-			const { total, found } = numericSum(String(field));
-			if (found > 0) out[`avg_${String(field)}`] = total / found;
-		}
-
-		return Object.keys(out).length ? out : null;
-	};
-
-	for (const key of params.populateKeys) {
-		const forwardTarget = tableRefs.get(key);
-		const backwardCandidates = reverseRefs.get(params.currentTable) ?? [];
-		const backward = backwardCandidates.find((c) => c.table === key);
-		const includeDocs = includeDocsConfig[key] ?? true;
-		let valueById: Map<string, Record<string, unknown>[]> | undefined;
-		let handled = false;
-
-		// Prefer forward populate via $lookup when the table carries the ref.
-		if (forwardTarget) {
-			const hasForwardValues = params.docs.some((doc) => {
-				const value = doc[key];
-				return Array.isArray(value)
-					? value.length > 0
-					: value !== undefined && value !== null;
-			});
-
-			if (hasForwardValues) {
-				const coll = params.getCollection(params.currentTable);
-				const pipeline = [
-					{ $match: { _id: { $in: docIds } } },
-					{
-						$lookup: {
-							from: forwardTarget,
-							localField: key,
-							foreignField: "_id",
-							as: "__pop",
-						},
-					},
-					{ $project: { _id: 1, __pop: 1 } },
-				];
-
-				const populated = (await coll
-					.aggregate(pipeline as any)
-					.toArray()) as Array<Record<string, unknown>>;
-
-				const byId = buildLookupMap(populated);
-				valueById = byId;
-				handled = true;
-
-				if (includeDocs) {
-					for (const doc of params.docs) {
-						const docId = ensureStringId(doc._id);
-						if (!docId) continue;
-						const populatedDocs = byId.get(docId) ?? [];
-						const currentValue = doc[key];
-
-						if (Array.isArray(currentValue)) {
-							const byRelId = new Map<string, Record<string, unknown>>();
-							for (const rel of populatedDocs) {
-								const relId = ensureStringId(rel._id);
-								if (relId) byRelId.set(relId, rel);
-							}
-							doc[key] = currentValue
-								.map((v) => {
-									const relId = ensureStringId(v);
-									return relId ? (byRelId.get(relId) ?? null) : null;
-								})
-								.filter((v): v is Record<string, unknown> => Boolean(v));
-							continue;
-						}
-
-						const relId = ensureStringId(currentValue);
-						doc[key] = relId
-							? (populatedDocs.find((v) => ensureStringId(v._id) === relId) ??
-								currentValue)
-							: (populatedDocs[0] ?? currentValue);
-					}
-				}
-
-				continue;
-			}
-
-			if (!backward) continue;
-		}
-
-		// Backward populate: find docs in another table that reference this table's _id.
-		if (backward) {
-			const coll = params.getCollection(params.currentTable);
-			const pipeline = [
-				{ $match: { _id: { $in: docIds } } },
-				{
-					$lookup: {
-						from: backward.table,
-						localField: "_id",
-						foreignField: backward.field,
-						as: "__pop",
-					},
-				},
-				{ $project: { _id: 1, __pop: 1 } },
-			];
-			const populated = (await coll
-				.aggregate(pipeline as any)
-				.toArray()) as Array<Record<string, unknown>>;
-			if (!handled && backward) {
-				const grouped = buildLookupMap(populated);
-				valueById = grouped;
-
-				if (includeDocs) {
-					for (const doc of params.docs) {
-						const id = ensureStringId(doc._id);
-						if (!id) continue;
-						doc[key] = grouped.get(id) ?? [];
-					}
-				}
-			}
-		}
-
-		const aggregateSpec = aggregateConfig[key];
-		if (aggregateSpec) {
-			for (const doc of params.docs) {
-				const docId = ensureStringId(doc._id);
-				if (!docId) continue;
-				const aggregateSource = valueById?.get(docId) ?? doc[key];
-				const aggregated = computeAggregates(aggregateSource, aggregateSpec);
-				if (!aggregated) continue;
-				const existing = (doc as any)._aggregates as
-					| Record<string, unknown>
-					| undefined;
-				const target = existing ?? ((doc as any)._aggregates = {});
-				target[key] = aggregated;
-			}
-		}
-	}
-}