faire-auth 1.0.3 → 1.1.0

package/dist/adapters/kysely-adapter/index.d.cts

@@ -1,26 +1,17 @@
-import { I as FaireAuthOptions, Wt as KyselyDatabaseType } from "../../index-CsWF3f7U.cjs";
-import "../../hono-DOM31WQz.cjs";
+import { ht as FaireAuthOptions, qt as KyselyDatabaseType } from "../../shared.cjs";
 import { DBAdapter, DBAdapterDebugLogOption } from "@faire-auth/core/db/adapter";
 import { Kysely } from "kysely";
-
-//#region src/adapters/kysely-adapter/dialect.d.ts
-declare function getKyselyDatabaseType(db: FaireAuthOptions["database"]): KyselyDatabaseType | null;
-declare const createKyselyAdapter: (config: FaireAuthOptions) => {
+export declare function getKyselyDatabaseType(db: FaireAuthOptions["database"]): KyselyDatabaseType | null;
+export declare const createKyselyAdapter: (config: FaireAuthOptions) => {
+  kysely: any;
+  databaseType: any;
+  transaction: any;
+} | {
   kysely: Kysely<any> | null;
   databaseType: KyselyDatabaseType | null;
   transaction: undefined;
   initialize(): Promise<void>;
-} | {
-  kysely: null;
-  databaseType: null;
-  transaction: undefined;
-} | {
-  kysely: Kysely<any>;
-  databaseType: "postgres" | "mysql" | "sqlite" | "mssql";
-  transaction: boolean | undefined;
 };
-//#endregion
-//#region src/adapters/kysely-adapter/kysely-adapter.d.ts
 interface KyselyAdapterConfig {
   /**
    * Database type.
@@ -47,6 +38,5 @@ interface KyselyAdapterConfig {
    */
   transaction?: boolean | undefined;
 }
-declare const kyselyAdapter: (db: Kysely<any> | Promise<Kysely<any>>, config?: KyselyAdapterConfig) => (options: FaireAuthOptions) => DBAdapter<FaireAuthOptions>;
-//#endregion
-export { KyselyDatabaseType, createKyselyAdapter, getKyselyDatabaseType, kyselyAdapter };
+export declare const kyselyAdapter: (db: Kysely<any> | Promise<Kysely<any>>, config?: KyselyAdapterConfig) => (options: FaireAuthOptions) => DBAdapter<FaireAuthOptions>;
+export { KyselyDatabaseType };

package/dist/adapters/kysely-adapter/index.d.mts

@@ -1,26 +1,17 @@
-import { I as FaireAuthOptions, Wt as KyselyDatabaseType } from "../../index-rFv8Hxld.mjs";
-import "../../hono-D0VqxVy1.mjs";
+import { Jt as KyselyDatabaseType, gt as FaireAuthOptions } from "../../shared.mjs";
 import { Kysely } from "kysely";
 import { DBAdapter, DBAdapterDebugLogOption } from "@faire-auth/core/db/adapter";
-
-//#region src/adapters/kysely-adapter/dialect.d.ts
-declare function getKyselyDatabaseType(db: FaireAuthOptions["database"]): KyselyDatabaseType | null;
-declare const createKyselyAdapter: (config: FaireAuthOptions) => {
+export declare function getKyselyDatabaseType(db: FaireAuthOptions["database"]): KyselyDatabaseType | null;
+export declare const createKyselyAdapter: (config: FaireAuthOptions) => {
+  kysely: any;
+  databaseType: any;
+  transaction: any;
+} | {
   kysely: Kysely<any> | null;
   databaseType: KyselyDatabaseType | null;
   transaction: undefined;
   initialize(): Promise<void>;
-} | {
-  kysely: null;
-  databaseType: null;
-  transaction: undefined;
-} | {
-  kysely: Kysely<any>;
-  databaseType: "postgres" | "mysql" | "sqlite" | "mssql";
-  transaction: boolean | undefined;
 };
-//#endregion
-//#region src/adapters/kysely-adapter/kysely-adapter.d.ts
 interface KyselyAdapterConfig {
   /**
    * Database type.
@@ -47,6 +38,5 @@ interface KyselyAdapterConfig {
    */
   transaction?: boolean | undefined;
 }
-declare const kyselyAdapter: (db: Kysely<any> | Promise<Kysely<any>>, config?: KyselyAdapterConfig) => (options: FaireAuthOptions) => DBAdapter<FaireAuthOptions>;
-//#endregion
-export { KyselyDatabaseType, createKyselyAdapter, getKyselyDatabaseType, kyselyAdapter };
+export declare const kyselyAdapter: (db: Kysely<any> | Promise<Kysely<any>>, config?: KyselyAdapterConfig) => (options: FaireAuthOptions) => DBAdapter<FaireAuthOptions>;
+export { KyselyDatabaseType };

package/dist/adapters/kysely-adapter/index.mjs

@@ -1,9 +1,267 @@
-import "../../crypto-DH2Aa7jN.mjs";
-import "../../json-B1v2qRTQ.mjs";
-import "../../state-CQghgH9I.mjs";
-import "../../request-1NL_1lyJ.mjs";
-import "../../utils-D4vZd1-9.mjs";
-import { n as createKyselyAdapter, r as getKyselyDatabaseType, t as kyselyAdapter } from "../../kysely-adapter-CtIdoHa8.mjs";
-import "../../adapter-factory-lKIOf2OR.mjs";
-
-export { createKyselyAdapter, getKyselyDatabaseType, kyselyAdapter };
+import { t as createAdapterFactory } from "../../adapter-factory-qPVW8x9-.mjs";
+import { isPromise } from "@faire-auth/core/static";
+import { Kysely, MssqlDialect, MysqlDialect, PostgresDialect, SqliteDialect } from "kysely";
+// src/adapters/kysely-adapter/dialect.ts
+function getKyselyDatabaseType(db) {
+	if (!db) return null;
+	if ("dialect" in db) return getKyselyDatabaseType(db.dialect);
+	if ("createDriver" in db) {
+		if (db instanceof SqliteDialect) return "sqlite";
+		if (db instanceof MysqlDialect) return "mysql";
+		if (db instanceof PostgresDialect) return "postgres";
+		if (db instanceof MssqlDialect) return "mssql";
+	}
+	if ("aggregate" in db) return "sqlite";
+	if ("getConnection" in db) return "mysql";
+	if ("connect" in db) return "postgres";
+	if ("fileControl" in db) return "sqlite";
+	if ("open" in db && "close" in db && "prepare" in db) return "sqlite";
+	return null;
+}
+const createKyselyAdapter = (config) => {
+	const db = config.database;
+	if (!db) return {
+		kysely: null,
+		databaseType: null,
+		transaction: void 0
+	};
+	if ("db" in db) return {
+		kysely: db.db,
+		databaseType: db.type,
+		transaction: db.transaction
+	};
+	if ("dialect" in db) return {
+		kysely: new Kysely({ dialect: db.dialect }),
+		databaseType: db.type,
+		transaction: db.transaction
+	};
+	let dialect = void 0;
+	const databaseType = getKyselyDatabaseType(db);
+	if ("createDriver" in db) dialect = db;
+	if ("aggregate" in db && !("createSession" in db)) dialect = new SqliteDialect({ database: db });
+	if ("getConnection" in db) dialect = new MysqlDialect(db);
+	if ("connect" in db) dialect = new PostgresDialect({ pool: db });
+	const toReturn = {
+		kysely: dialect ? new Kysely({ dialect }) : null,
+		databaseType,
+		transaction: void 0,
+		async initialize() {
+			if (toReturn.kysely == null) {
+				if ("fileControl" in db) {
+					console.log("found file control");
+					const { BunSqliteDialect } = await import("../../bun-sqlite-dialect-BiZBuEF6.mjs");
+					dialect = new BunSqliteDialect({ database: db });
+				}
+				if ("createSession" in db && typeof window === "undefined") {
+					console.log("found create session");
+					let DatabaseSync = void 0;
+					try {
+						let nodeSqlite = "node:sqlite";
+						({DatabaseSync} = await import(
+							/* @vite-ignore */
+							/* webpackIgnore: true */
+							nodeSqlite
+));
+					} catch (error) {
+						console.log("caught");
+						if (error !== null && typeof error === "object" && "code" in error && error.code !== "ERR_UNKNOWN_BUILTIN_MODULE") throw error;
+					}
+					console.log("import dialect");
+					if (DatabaseSync && db instanceof DatabaseSync) {
+						const { NodeSqliteDialect } = await import("../../node-sqlite-dialect-BMVOjEMh.mjs");
+						dialect = new NodeSqliteDialect({ database: db });
+					}
+				}
+				if (dialect) toReturn.kysely = new Kysely({ dialect });
+			}
+		}
+	};
+	return toReturn;
+};
+// src/adapters/kysely-adapter/kysely-adapter.ts
+const withDbInit = (db, work) => async (fn) => {
+	const rdb = isPromise(db) ? await db : db;
+	if (work) work(rdb);
+	return fn(rdb);
+};
+const kyselyAdapter = (db, config) => {
+	let lazyOptions = null;
+	const withDb = withDbInit(db);
+	const createCustomAdapter = (db) => {
+		return ({ getFieldName }) => {
+			const withReturningInit = (db) => async (values, builder, model, where) => {
+				let res;
+				if (config?.type === "mysql") {
+					await builder.execute();
+					const field = values.id ? "id" : where.length > 0 && where[0]?.field ? where[0].field : "id";
+					if (!values.id && where.length === 0) {
+						res = await db.selectFrom(model).selectAll().orderBy(getFieldName({
+							model,
+							field
+						}), "desc").limit(1).executeTakeFirst();
+						return res;
+					}
+					const value = values[field] || where[0]?.value;
+					res = await db.selectFrom(model).selectAll().orderBy(getFieldName({
+						model,
+						field
+					}), "desc").where(getFieldName({
+						model,
+						field
+					}), "=", value).limit(1).executeTakeFirst();
+					return res;
+				}
+				if (config?.type === "mssql") {
+					res = await builder.outputAll("inserted").executeTakeFirst();
+					return res;
+				}
+				res = await builder.returningAll().executeTakeFirst();
+				return res;
+			};
+			let withReturning;
+			const withDb = withDbInit(db, (db) => withReturning ??= withReturningInit(db));
+			function convertWhereClause(model, w) {
+				if (!w) return {
+					and: null,
+					or: null
+				};
+				const conditions = {
+					and: [],
+					or: []
+				};
+				w.forEach((condition) => {
+					let { field: _field, value: _value, operator = "=", connector = "AND" } = condition;
+					let value = _value;
+					let field = getFieldName({
+						model,
+						field: _field
+					});
+					const expr = (eb) => {
+						if (operator.toLowerCase() === "in") return eb(field, "in", Array.isArray(value) ? value : [value]);
+						if (operator.toLowerCase() === "not_in") return eb(field, "not in", Array.isArray(value) ? value : [value]);
+						if (operator === "contains") return eb(field, "like", `%${value}%`);
+						if (operator === "starts_with") return eb(field, "like", `${value}%`);
+						if (operator === "ends_with") return eb(field, "like", `%${value}`);
+						if (operator === "eq") return eb(field, "=", value);
+						if (operator === "ne") return eb(field, "<>", value);
+						if (operator === "gt") return eb(field, ">", value);
+						if (operator === "gte") return eb(field, ">=", value);
+						if (operator === "lt") return eb(field, "<", value);
+						if (operator === "lte") return eb(field, "<=", value);
+						return eb(field, operator, value);
+					};
+					if (connector === "OR") conditions.or.push(expr);
+					else conditions.and.push(expr);
+				});
+				return {
+					and: conditions.and.length ? conditions.and : null,
+					or: conditions.or.length ? conditions.or : null
+				};
+			}
+			return {
+				create: ({ data, model }) => withDb(async (db) => {
+					const builder = db.insertInto(model).values(data);
+					return await withReturning(data, builder, model, []);
+				}),
+				findOne: ({ model, where, select }) => withDb(async (db) => {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db.selectFrom(model).selectAll();
+					if (and) query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
+					if (or) query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
+					const res = await query.executeTakeFirst();
+					if (!res) return null;
+					return res;
+				}),
+				findMany: ({ model, where, limit, offset, sortBy }) => withDb(async (db) => {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db.selectFrom(model);
+					if (and) query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
+					if (or) query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
+					if (config?.type === "mssql") {
+						if (!offset) query = query.top(limit || 100);
+					} else query = query.limit(limit || 100);
+					if (sortBy) query = query.orderBy(getFieldName({
+						model,
+						field: sortBy.field
+					}), sortBy.direction);
+					if (offset) {
+						if (config?.type === "mssql") {
+							if (!sortBy) query = query.orderBy(getFieldName({
+								model,
+								field: "id"
+							}));
+							query = query.offset(offset).fetch(limit || 100);
+						} else query = query.offset(offset);
+					}
+					const res = await query.selectAll().execute();
+					if (!res) return [];
+					return res;
+				}),
+				update: ({ model, where, update: values }) => withDb(async (db) => {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db.updateTable(model).set(values);
+					if (and) query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
+					if (or) query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
+					return await withReturning(values, query, model, where);
+				}),
+				updateMany: ({ model, where, update: values }) => withDb(async (db) => {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db.updateTable(model).set(values);
+					if (and) query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
+					if (or) query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
+					return (await query.execute()).length;
+				}),
+				count: ({ model, where }) => withDb(async (db) => {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db.selectFrom(model).select(db.fn.count("id").as("count"));
+					if (and) query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
+					if (or) query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
+					const res = await query.execute();
+					if (typeof res[0].count === "number") return res[0].count;
+					if (typeof res[0].count === "bigint") return Number(res[0].count);
+					return parseInt(res[0].count);
+				}),
+				delete: ({ model, where }) => withDb(async (db) => {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db.deleteFrom(model);
+					if (and) query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
+					if (or) query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
+					await query.execute();
+				}),
+				deleteMany: ({ model, where }) => withDb(async (db) => {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db.deleteFrom(model);
+					if (and) query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
+					if (or) query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
+					return (await query.execute()).length;
+				}),
+				options: config
+			};
+		};
+	};
+	let adapterOptions = null;
+	adapterOptions = {
+		config: {
+			adapterId: "kysely",
+			adapterName: "Kysely Adapter",
+			usePlural: config?.usePlural,
+			debugLogs: config?.debugLogs,
+			supportsBooleans: config?.type === "sqlite" || config?.type === "mssql" || config?.type === "mysql" || !config?.type ? false : true,
+			supportsDates: config?.type === "sqlite" || config?.type === "mssql" || !config?.type ? false : true,
+			supportsJSON: false,
+			transaction: config?.transaction ?? false ? (cb) => withDb((db) => db.transaction().execute(((trx) => {
+				return cb(createAdapterFactory({
+					config: adapterOptions.config,
+					adapter: createCustomAdapter(trx)
+				})(lazyOptions));
+			}))) : false
+		},
+		adapter: createCustomAdapter(db)
+	};
+	const adapter = createAdapterFactory(adapterOptions);
+	return (options) => {
+		lazyOptions = options;
+		return adapter(options);
+	};
+};
+export { createKyselyAdapter, getKyselyDatabaseType, kyselyAdapter };

package/dist/adapters/memory-adapter/index.cjs

@@ -1,9 +1,146 @@
-require('../../crypto-DpSCnrTp.cjs');
-require('../../json--tl7Grvs.cjs');
-require('../../state-CvSihlVT.cjs');
-require('../../request-CPNlp-DK.cjs');
-require('../../utils-44aDDP8f.cjs');
-require('../../adapter-factory-D1I7joki.cjs');
-const require_memory_adapter = require('../../memory-adapter-17RZd5df.cjs');
-
-exports.memoryAdapter = require_memory_adapter.memoryAdapter;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_adapter_factory = require("../../adapter-factory-u8r3oTez.cjs");
+let _faire_auth_core_env = require("@faire-auth/core/env");
+// 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);
+	};
+};
+exports.memoryAdapter = memoryAdapter;

package/dist/adapters/memory-adapter/index.d.cts

@@ -1,15 +1,9 @@
-import { I as FaireAuthOptions } from "../../index-CsWF3f7U.cjs";
-import "../../hono-DOM31WQz.cjs";
+import { ht as FaireAuthOptions } from "../../shared.cjs";
 import { DBAdapterDebugLogOption } from "@faire-auth/core/db/adapter";
-import * as _faire_auth_core_db22 from "@faire-auth/core/db";
-
-//#region src/adapters/memory-adapter/memory-adapter.d.ts
-interface MemoryDB {
+export interface MemoryDB {
   [key: string]: any[];
 }
-interface MemoryAdapterConfig {
+export interface MemoryAdapterConfig {
   debugLogs?: DBAdapterDebugLogOption;
 }
-declare const memoryAdapter: (db: MemoryDB, config?: MemoryAdapterConfig) => (options: FaireAuthOptions) => _faire_auth_core_db22.DBAdapter<FaireAuthOptions>;
-//#endregion
-export { MemoryAdapterConfig, MemoryDB, memoryAdapter };
+export declare const memoryAdapter: (db: MemoryDB, config?: MemoryAdapterConfig) => (options: FaireAuthOptions) => DBAdapter<O>;

package/dist/adapters/memory-adapter/index.d.mts

@@ -1,15 +1,9 @@
-import { I as FaireAuthOptions } from "../../index-rFv8Hxld.mjs";
-import "../../hono-D0VqxVy1.mjs";
-import * as _faire_auth_core_db15 from "@faire-auth/core/db";
+import { gt as FaireAuthOptions } from "../../shared.mjs";
 import { DBAdapterDebugLogOption } from "@faire-auth/core/db/adapter";
-
-//#region src/adapters/memory-adapter/memory-adapter.d.ts
-interface MemoryDB {
+export interface MemoryDB {
   [key: string]: any[];
 }
-interface MemoryAdapterConfig {
+export interface MemoryAdapterConfig {
   debugLogs?: DBAdapterDebugLogOption;
 }
-declare const memoryAdapter: (db: MemoryDB, config?: MemoryAdapterConfig) => (options: FaireAuthOptions) => _faire_auth_core_db15.DBAdapter<FaireAuthOptions>;
-//#endregion
-export { MemoryAdapterConfig, MemoryDB, memoryAdapter };
+export declare const memoryAdapter: (db: MemoryDB, config?: MemoryAdapterConfig) => (options: FaireAuthOptions) => DBAdapter<O>;