faire-auth 1.0.0

package/dist/logged-CyGfp8_H.mjs

@@ -0,0 +1,187 @@
+import { isCI, isTest } from "@faire-auth/core/env";
+
+//#region src/utils/logged.ts
+let _nodeInspect;
+const inspect = (object) => {
+	if (!_nodeInspect) return String(object);
+	return _nodeInspect(object, { colors: true });
+};
+if (typeof globalThis.process !== "undefined") import("node:util").then((m) => {
+	_nodeInspect = m.inspect;
+}).catch(() => {});
+const MAX_SIZE = 100;
+var LogQueue = class {
+	queue = [];
+	maxSize;
+	constructor(maxSize = MAX_SIZE) {
+		this.maxSize = maxSize;
+	}
+	push(log) {
+		this.queue.push(log);
+		if (this.queue.length > this.maxSize) this.queue.shift();
+	}
+	read() {
+		return this.queue.shift();
+	}
+	readN(n) {
+		return this.queue.splice(0, n);
+	}
+	readAll() {
+		return this.queue.splice(0);
+	}
+	peek() {
+		return this.queue[0];
+	}
+	peekN(n) {
+		return this.queue.slice(0, n);
+	}
+	peekAll() {
+		return [...this.queue];
+	}
+	size() {
+		return this.queue.length;
+	}
+	clear() {
+		this.queue.length = 0;
+	}
+	setMaxSize(size) {
+		this.maxSize = size;
+		if (this.queue.length > size) this.queue.splice(0, this.queue.length - size);
+	}
+	[Symbol.iterator]() {
+		return { next: () => {
+			const log = this.queue.shift();
+			if (log === void 0) return {
+				done: true,
+				value: void 0
+			};
+			return {
+				done: false,
+				value: log
+			};
+		} };
+	}
+	async *watch() {
+		while (true) {
+			const log = this.queue.shift();
+			if (log) yield log;
+			else await new Promise((resolve) => setTimeout(resolve, 10));
+		}
+	}
+};
+const logQueue = new LogQueue();
+const LoggerAPI = {
+	wrap(target, prefix = "", strategy = "queue") {
+		return logged(target, prefix, strategy);
+	},
+	clear() {
+		logQueue.clear();
+	},
+	get size() {
+		return logQueue.size();
+	},
+	set size(newSize) {
+		logQueue.setMaxSize(newSize);
+	},
+	read: {
+		next(n) {
+			if (n == null) return logQueue.read();
+			return logQueue.readN(n);
+		},
+		all() {
+			return logQueue.readAll();
+		}
+	},
+	peek: {
+		next(n) {
+			if (n == null) return logQueue.peek();
+			return logQueue.peekN(n);
+		},
+		all() {
+			return logQueue.peekAll();
+		}
+	},
+	[Symbol.iterator]() {
+		return logQueue[Symbol.iterator]();
+	},
+	watch() {
+		return logQueue.watch();
+	}
+};
+function printLogs(logs = LoggerAPI.read.all()) {
+	if (logs.length === 0) return;
+	logs.forEach((log, i) => {
+		console.log(`${log.duration.toFixed(2)}ms \x1b[35m\x1b[1m${log.method}\x1b[0m(${log.input.join(", ")}): ${log.error ? inspect(log.error) : log.output}`);
+	});
+}
+function wrapFunction(fn, method, strategy) {
+	const queue = strategy === "immediate" ? new LogQueue() : logQueue;
+	const onComplete = () => {
+		if (strategy === "immediate") printLogs(queue.readAll());
+	};
+	return new Proxy(fn, { apply(target, thisArg, args) {
+		const input = args.map((a) => inspect(a));
+		const timestamp = /* @__PURE__ */ new Date();
+		const startTime = performance.now();
+		try {
+			const result = target.apply(thisArg, args);
+			if (result instanceof Promise) return result.then((resolvedValue) => {
+				const duration$1 = performance.now() - startTime;
+				queue.push({
+					method,
+					input,
+					output: inspect(resolvedValue),
+					timestamp,
+					duration: duration$1
+				});
+				return resolvedValue;
+			}, (error) => {
+				const duration$1 = performance.now() - startTime;
+				queue.push({
+					method,
+					input,
+					output: "None",
+					timestamp,
+					duration: duration$1,
+					error
+				});
+				throw error;
+			}).finally(onComplete);
+			const duration = performance.now() - startTime;
+			queue.push({
+				method,
+				input,
+				output: inspect(result),
+				timestamp,
+				duration
+			});
+			return result;
+		} catch (error) {
+			const duration = performance.now() - startTime;
+			queue.push({
+				method,
+				input,
+				output: "None",
+				timestamp,
+				duration,
+				error
+			});
+			throw error;
+		} finally {
+			onComplete();
+		}
+	} });
+}
+function logged(target, name, strategy = "queue") {
+	if (!isTest() || isCI()) return target;
+	if (typeof target === "function") return wrapFunction(target, name || target.name || "anonymous", strategy);
+	return new Proxy(target, { get(obj, prop) {
+		const value = obj[prop];
+		if (typeof value !== "function") return value;
+		return wrapFunction(value, name ? `${name}.${String(prop)}` : String(prop), strategy);
+	} });
+}
+var logged_default = LoggerAPI;
+
+//#endregion
+export { logged_default as t };

package/dist/logged-DQK3C64b.cjs

@@ -0,0 +1,193 @@
+const require_chunk = require('./chunk-oakRccI5.cjs');
+let __faire_auth_core_env = require("@faire-auth/core/env");
+
+//#region src/utils/logged.ts
+let _nodeInspect;
+const inspect = (object) => {
+	if (!_nodeInspect) return String(object);
+	return _nodeInspect(object, { colors: true });
+};
+if (typeof globalThis.process !== "undefined") import("node:util").then((m) => {
+	_nodeInspect = m.inspect;
+}).catch(() => {});
+const MAX_SIZE = 100;
+var LogQueue = class {
+	queue = [];
+	maxSize;
+	constructor(maxSize = MAX_SIZE) {
+		this.maxSize = maxSize;
+	}
+	push(log) {
+		this.queue.push(log);
+		if (this.queue.length > this.maxSize) this.queue.shift();
+	}
+	read() {
+		return this.queue.shift();
+	}
+	readN(n) {
+		return this.queue.splice(0, n);
+	}
+	readAll() {
+		return this.queue.splice(0);
+	}
+	peek() {
+		return this.queue[0];
+	}
+	peekN(n) {
+		return this.queue.slice(0, n);
+	}
+	peekAll() {
+		return [...this.queue];
+	}
+	size() {
+		return this.queue.length;
+	}
+	clear() {
+		this.queue.length = 0;
+	}
+	setMaxSize(size) {
+		this.maxSize = size;
+		if (this.queue.length > size) this.queue.splice(0, this.queue.length - size);
+	}
+	[Symbol.iterator]() {
+		return { next: () => {
+			const log = this.queue.shift();
+			if (log === void 0) return {
+				done: true,
+				value: void 0
+			};
+			return {
+				done: false,
+				value: log
+			};
+		} };
+	}
+	async *watch() {
+		while (true) {
+			const log = this.queue.shift();
+			if (log) yield log;
+			else await new Promise((resolve) => setTimeout(resolve, 10));
+		}
+	}
+};
+const logQueue = new LogQueue();
+const LoggerAPI = {
+	wrap(target, prefix = "", strategy = "queue") {
+		return logged(target, prefix, strategy);
+	},
+	clear() {
+		logQueue.clear();
+	},
+	get size() {
+		return logQueue.size();
+	},
+	set size(newSize) {
+		logQueue.setMaxSize(newSize);
+	},
+	read: {
+		next(n) {
+			if (n == null) return logQueue.read();
+			return logQueue.readN(n);
+		},
+		all() {
+			return logQueue.readAll();
+		}
+	},
+	peek: {
+		next(n) {
+			if (n == null) return logQueue.peek();
+			return logQueue.peekN(n);
+		},
+		all() {
+			return logQueue.peekAll();
+		}
+	},
+	[Symbol.iterator]() {
+		return logQueue[Symbol.iterator]();
+	},
+	watch() {
+		return logQueue.watch();
+	}
+};
+function printLogs(logs = LoggerAPI.read.all()) {
+	if (logs.length === 0) return;
+	logs.forEach((log, i) => {
+		console.log(`${log.duration.toFixed(2)}ms \x1b[35m\x1b[1m${log.method}\x1b[0m(${log.input.join(", ")}): ${log.error ? inspect(log.error) : log.output}`);
+	});
+}
+function wrapFunction(fn, method, strategy) {
+	const queue = strategy === "immediate" ? new LogQueue() : logQueue;
+	const onComplete = () => {
+		if (strategy === "immediate") printLogs(queue.readAll());
+	};
+	return new Proxy(fn, { apply(target, thisArg, args) {
+		const input = args.map((a) => inspect(a));
+		const timestamp = /* @__PURE__ */ new Date();
+		const startTime = performance.now();
+		try {
+			const result = target.apply(thisArg, args);
+			if (result instanceof Promise) return result.then((resolvedValue) => {
+				const duration$1 = performance.now() - startTime;
+				queue.push({
+					method,
+					input,
+					output: inspect(resolvedValue),
+					timestamp,
+					duration: duration$1
+				});
+				return resolvedValue;
+			}, (error) => {
+				const duration$1 = performance.now() - startTime;
+				queue.push({
+					method,
+					input,
+					output: "None",
+					timestamp,
+					duration: duration$1,
+					error
+				});
+				throw error;
+			}).finally(onComplete);
+			const duration = performance.now() - startTime;
+			queue.push({
+				method,
+				input,
+				output: inspect(result),
+				timestamp,
+				duration
+			});
+			return result;
+		} catch (error) {
+			const duration = performance.now() - startTime;
+			queue.push({
+				method,
+				input,
+				output: "None",
+				timestamp,
+				duration,
+				error
+			});
+			throw error;
+		} finally {
+			onComplete();
+		}
+	} });
+}
+function logged(target, name, strategy = "queue") {
+	if (!(0, __faire_auth_core_env.isTest)() || (0, __faire_auth_core_env.isCI)()) return target;
+	if (typeof target === "function") return wrapFunction(target, name || target.name || "anonymous", strategy);
+	return new Proxy(target, { get(obj, prop) {
+		const value = obj[prop];
+		if (typeof value !== "function") return value;
+		return wrapFunction(value, name ? `${name}.${String(prop)}` : String(prop), strategy);
+	} });
+}
+var logged_default = LoggerAPI;
+
+//#endregion
+Object.defineProperty(exports, 'logged_default', {
+  enumerable: true,
+  get: function () {
+    return logged_default;
+  }
+});

package/dist/memory-adapter-BlnDIAAX.cjs

@@ -0,0 +1,154 @@
+const require_chunk = require('./chunk-oakRccI5.cjs');
+const require_adapter_factory = require('./adapter-factory-DT-_2aHJ.cjs');
+let __faire_auth_core_env = require("@faire-auth/core/env");
+
+//#region src/adapters/memory-adapter/memory-adapter.ts
+const memoryAdapter = (db, config) => {
+	let lazyOptions = null;
+	let adapterCreator = require_adapter_factory.createAdapterFactory({
+		config: {
+			adapterId: "memory",
+			adapterName: "Memory Adapter",
+			usePlural: false,
+			debugLogs: config?.debugLogs || false,
+			customTransformInput(props) {
+				if (props.options.advanced?.database?.useNumberId && props.field === "id" && props.action === "create") return db[props.model].length + 1;
+				return props.data;
+			},
+			transaction: async (cb) => {
+				let clone = structuredClone(db);
+				try {
+					return await cb(adapterCreator(lazyOptions));
+				} catch (error) {
+					Object.keys(db).forEach((key) => {
+						db[key] = clone[key];
+					});
+					throw error;
+				}
+			}
+		},
+		adapter: ({ getFieldName, options, debugLog }) => {
+			function convertWhereClause(where, model) {
+				const table = db[model];
+				if (!table) {
+					__faire_auth_core_env.logger.error(`[MemoryAdapter] Model ${model} not found in the DB`, Object.keys(db));
+					throw new Error(`Model ${model} not found`);
+				}
+				const evalClause = (record, clause) => {
+					const { field, value, operator } = clause;
+					switch (operator) {
+						case "in":
+							if (!Array.isArray(value)) throw new Error("Value must be an array");
+							return value.includes(record[field]);
+						case "not_in":
+							if (!Array.isArray(value)) throw new Error("Value must be an array");
+							return !value.includes(record[field]);
+						case "contains": return record[field].includes(value);
+						case "starts_with": return record[field].startsWith(value);
+						case "ends_with": return record[field].endsWith(value);
+						case "ne": return record[field] !== value;
+						case "gt": return value != null && Boolean(record[field] > value);
+						case "gte": return value != null && Boolean(record[field] >= value);
+						case "lt": return value != null && Boolean(record[field] < value);
+						case "lte": return value != null && Boolean(record[field] <= value);
+						default: return record[field] === value;
+					}
+				};
+				return table.filter((record) => {
+					if (!where.length || where.length === 0) return true;
+					let result = evalClause(record, where[0]);
+					for (const clause of where) {
+						const clauseResult = evalClause(record, clause);
+						if (clause.connector === "OR") result = result || clauseResult;
+						else result = result && clauseResult;
+					}
+					return result;
+				});
+			}
+			return {
+				create: async ({ model, data }) => {
+					if (options.advanced?.database?.useNumberId) data.id = db[model].length + 1;
+					if (!db[model]) db[model] = [];
+					db[model].push(data);
+					return data;
+				},
+				findOne: async ({ model, where }) => {
+					return convertWhereClause(where, model)[0] || null;
+				},
+				findMany: async ({ model, where, sortBy, limit, offset }) => {
+					let table = db[model];
+					if (where) table = convertWhereClause(where, model);
+					if (sortBy) table = table.sort((a, b) => {
+						const field = getFieldName({
+							model,
+							field: sortBy.field
+						});
+						const aValue = a[field];
+						const bValue = b[field];
+						let comparison = 0;
+						if (aValue == null && bValue == null) comparison = 0;
+						else if (aValue == null) comparison = -1;
+						else if (bValue == null) comparison = 1;
+						else if (typeof aValue === "string" && typeof bValue === "string") comparison = aValue.localeCompare(bValue);
+						else if (aValue instanceof Date && bValue instanceof Date) comparison = aValue.getTime() - bValue.getTime();
+						else if (typeof aValue === "number" && typeof bValue === "number") comparison = aValue - bValue;
+						else if (typeof aValue === "boolean" && typeof bValue === "boolean") comparison = aValue === bValue ? 0 : aValue ? 1 : -1;
+						else comparison = String(aValue).localeCompare(String(bValue));
+						return sortBy.direction === "asc" ? comparison : -comparison;
+					});
+					if (offset !== void 0) table = table.slice(offset);
+					if (limit !== void 0) table = table.slice(0, limit);
+					return table || [];
+				},
+				count: async ({ model, where }) => {
+					if (where) return convertWhereClause(where, model).length;
+					return db[model].length;
+				},
+				update: async ({ model, where, update }) => {
+					const res = convertWhereClause(where, model);
+					res.forEach((record) => {
+						Object.assign(record, update);
+					});
+					return res[0] || null;
+				},
+				delete: async ({ model, where }) => {
+					const table = db[model];
+					const res = convertWhereClause(where, model);
+					db[model] = table.filter((record) => !res.includes(record));
+				},
+				deleteMany: async ({ model, where }) => {
+					const table = db[model];
+					const res = convertWhereClause(where, model);
+					let count = 0;
+					db[model] = table.filter((record) => {
+						if (res.includes(record)) {
+							count++;
+							return false;
+						}
+						return !res.includes(record);
+					});
+					return count;
+				},
+				updateMany({ model, where, update }) {
+					const res = convertWhereClause(where, model);
+					res.forEach((record) => {
+						Object.assign(record, update);
+					});
+					return res[0] || null;
+				}
+			};
+		}
+	});
+	return (options) => {
+		lazyOptions = options;
+		return adapterCreator(options);
+	};
+};
+
+//#endregion
+Object.defineProperty(exports, 'memoryAdapter', {
+  enumerable: true,
+  get: function () {
+    return memoryAdapter;
+  }
+});

package/dist/memory-adapter-Db3tsJTn.mjs

@@ -0,0 +1,148 @@
+import { t as createAdapterFactory } from "./adapter-factory-BXei1QRX.mjs";
+import { logger } from "@faire-auth/core/env";
+
+//#region src/adapters/memory-adapter/memory-adapter.ts
+const memoryAdapter = (db, config) => {
+	let lazyOptions = null;
+	let adapterCreator = createAdapterFactory({
+		config: {
+			adapterId: "memory",
+			adapterName: "Memory Adapter",
+			usePlural: false,
+			debugLogs: config?.debugLogs || false,
+			customTransformInput(props) {
+				if (props.options.advanced?.database?.useNumberId && props.field === "id" && props.action === "create") return db[props.model].length + 1;
+				return props.data;
+			},
+			transaction: async (cb) => {
+				let clone = structuredClone(db);
+				try {
+					return await cb(adapterCreator(lazyOptions));
+				} catch (error) {
+					Object.keys(db).forEach((key) => {
+						db[key] = clone[key];
+					});
+					throw error;
+				}
+			}
+		},
+		adapter: ({ getFieldName, options, debugLog }) => {
+			function convertWhereClause(where, model) {
+				const table = db[model];
+				if (!table) {
+					logger.error(`[MemoryAdapter] Model ${model} not found in the DB`, Object.keys(db));
+					throw new Error(`Model ${model} not found`);
+				}
+				const evalClause = (record, clause) => {
+					const { field, value, operator } = clause;
+					switch (operator) {
+						case "in":
+							if (!Array.isArray(value)) throw new Error("Value must be an array");
+							return value.includes(record[field]);
+						case "not_in":
+							if (!Array.isArray(value)) throw new Error("Value must be an array");
+							return !value.includes(record[field]);
+						case "contains": return record[field].includes(value);
+						case "starts_with": return record[field].startsWith(value);
+						case "ends_with": return record[field].endsWith(value);
+						case "ne": return record[field] !== value;
+						case "gt": return value != null && Boolean(record[field] > value);
+						case "gte": return value != null && Boolean(record[field] >= value);
+						case "lt": return value != null && Boolean(record[field] < value);
+						case "lte": return value != null && Boolean(record[field] <= value);
+						default: return record[field] === value;
+					}
+				};
+				return table.filter((record) => {
+					if (!where.length || where.length === 0) return true;
+					let result = evalClause(record, where[0]);
+					for (const clause of where) {
+						const clauseResult = evalClause(record, clause);
+						if (clause.connector === "OR") result = result || clauseResult;
+						else result = result && clauseResult;
+					}
+					return result;
+				});
+			}
+			return {
+				create: async ({ model, data }) => {
+					if (options.advanced?.database?.useNumberId) data.id = db[model].length + 1;
+					if (!db[model]) db[model] = [];
+					db[model].push(data);
+					return data;
+				},
+				findOne: async ({ model, where }) => {
+					return convertWhereClause(where, model)[0] || null;
+				},
+				findMany: async ({ model, where, sortBy, limit, offset }) => {
+					let table = db[model];
+					if (where) table = convertWhereClause(where, model);
+					if (sortBy) table = table.sort((a, b) => {
+						const field = getFieldName({
+							model,
+							field: sortBy.field
+						});
+						const aValue = a[field];
+						const bValue = b[field];
+						let comparison = 0;
+						if (aValue == null && bValue == null) comparison = 0;
+						else if (aValue == null) comparison = -1;
+						else if (bValue == null) comparison = 1;
+						else if (typeof aValue === "string" && typeof bValue === "string") comparison = aValue.localeCompare(bValue);
+						else if (aValue instanceof Date && bValue instanceof Date) comparison = aValue.getTime() - bValue.getTime();
+						else if (typeof aValue === "number" && typeof bValue === "number") comparison = aValue - bValue;
+						else if (typeof aValue === "boolean" && typeof bValue === "boolean") comparison = aValue === bValue ? 0 : aValue ? 1 : -1;
+						else comparison = String(aValue).localeCompare(String(bValue));
+						return sortBy.direction === "asc" ? comparison : -comparison;
+					});
+					if (offset !== void 0) table = table.slice(offset);
+					if (limit !== void 0) table = table.slice(0, limit);
+					return table || [];
+				},
+				count: async ({ model, where }) => {
+					if (where) return convertWhereClause(where, model).length;
+					return db[model].length;
+				},
+				update: async ({ model, where, update }) => {
+					const res = convertWhereClause(where, model);
+					res.forEach((record) => {
+						Object.assign(record, update);
+					});
+					return res[0] || null;
+				},
+				delete: async ({ model, where }) => {
+					const table = db[model];
+					const res = convertWhereClause(where, model);
+					db[model] = table.filter((record) => !res.includes(record));
+				},
+				deleteMany: async ({ model, where }) => {
+					const table = db[model];
+					const res = convertWhereClause(where, model);
+					let count = 0;
+					db[model] = table.filter((record) => {
+						if (res.includes(record)) {
+							count++;
+							return false;
+						}
+						return !res.includes(record);
+					});
+					return count;
+				},
+				updateMany({ model, where, update }) {
+					const res = convertWhereClause(where, model);
+					res.forEach((record) => {
+						Object.assign(record, update);
+					});
+					return res[0] || null;
+				}
+			};
+		}
+	});
+	return (options) => {
+		lazyOptions = options;
+		return adapterCreator(options);
+	};
+};
+
+//#endregion
+export { memoryAdapter as t };

package/dist/middleware-CE6OhDkq.mjs

@@ -0,0 +1,29 @@
+//#region src/api/factory/middleware.ts
+/**
+* Creates a hook handler.
+* @template E - The environment type.
+* @template P - The path type.
+* @template I - The input type.
+* @param handler - The hook handler function.
+* @returns The hook handler.
+*/
+const createHook = () => (handler) => handler;
+/**
+* Creates a middleware handler.
+* @template E - The environment type.
+* @template P - The path type.
+* @template I - The input type.
+* @param handler - The middleware handler function.
+* @returns The middleware handler.
+*/
+const createMiddleware = () => (handler) => handler;
+/**
+* Creates an error handler.
+* @template E - The environment type.
+* @param handler - The error handler function.
+* @returns The error handler.
+*/
+const createErrorHandler = () => (handler) => handler;
+
+//#endregion
+export { createHook as n, createMiddleware as r, createErrorHandler as t };