appos 0.3.5-0 → 0.3.7-0

package/dist/exports/api/{auth-schema.mjs → auth-schema-CON4yFFY.mjs}

@@ -1,5 +1,4 @@
-import { sql } from "drizzle-orm";
-import { pgTable } from "drizzle-orm/pg-core";
+import { X as sql, r as pgTable } from "./table-6bTIEqON.mjs";
 
 //#region src/api/auth-schema.ts
 /**
@@ -370,4 +369,4 @@ function defineAuthSchema() {
 }
 
 //#endregion
-export { defineAuthSchema };
+export { defineAuthSchema as t };

package/dist/exports/api/bun-sqlite-dialect-CPpPZa23.mjs

@@ -0,0 +1,155 @@
+import { a as DEFAULT_MIGRATION_LOCK_TABLE, c as DefaultQueryCompiler, l as sql, o as DEFAULT_MIGRATION_TABLE, s as CompiledQuery } from "./esm-_hkVMulx.mjs";
+
+//#region ../../node_modules/.bun/better-auth@1.4.7+f768ad5b9455517d/node_modules/better-auth/dist/adapters/kysely-adapter/bun-sqlite-dialect.mjs
+var BunSqliteAdapter = class {
+	get supportsCreateIfNotExists() {
+		return true;
+	}
+	get supportsTransactionalDdl() {
+		return false;
+	}
+	get supportsReturning() {
+		return true;
+	}
+	async acquireMigrationLock() {}
+	async releaseMigrationLock() {}
+	get supportsOutput() {
+		return true;
+	}
+};
+var BunSqliteDriver = class {
+	#config;
+	#connectionMutex = new ConnectionMutex();
+	#db;
+	#connection;
+	constructor(config) {
+		this.#config = { ...config };
+	}
+	async init() {
+		this.#db = this.#config.database;
+		this.#connection = new BunSqliteConnection(this.#db);
+		if (this.#config.onCreateConnection) await this.#config.onCreateConnection(this.#connection);
+	}
+	async acquireConnection() {
+		await this.#connectionMutex.lock();
+		return this.#connection;
+	}
+	async beginTransaction(connection) {
+		await connection.executeQuery(CompiledQuery.raw("begin"));
+	}
+	async commitTransaction(connection) {
+		await connection.executeQuery(CompiledQuery.raw("commit"));
+	}
+	async rollbackTransaction(connection) {
+		await connection.executeQuery(CompiledQuery.raw("rollback"));
+	}
+	async releaseConnection() {
+		this.#connectionMutex.unlock();
+	}
+	async destroy() {
+		this.#db?.close();
+	}
+};
+var BunSqliteConnection = class {
+	#db;
+	constructor(db) {
+		this.#db = db;
+	}
+	executeQuery(compiledQuery) {
+		const { sql: sql$1, parameters } = compiledQuery;
+		const stmt = this.#db.prepare(sql$1);
+		return Promise.resolve({ rows: stmt.all(parameters) });
+	}
+	async *streamQuery() {
+		throw new Error("Streaming query is not supported by SQLite driver.");
+	}
+};
+var ConnectionMutex = class {
+	#promise;
+	#resolve;
+	async lock() {
+		while (this.#promise) await this.#promise;
+		this.#promise = new Promise((resolve) => {
+			this.#resolve = resolve;
+		});
+	}
+	unlock() {
+		const resolve = this.#resolve;
+		this.#promise = void 0;
+		this.#resolve = void 0;
+		resolve?.();
+	}
+};
+var BunSqliteIntrospector = class {
+	#db;
+	constructor(db) {
+		this.#db = db;
+	}
+	async getSchemas() {
+		return [];
+	}
+	async getTables(options = { withInternalKyselyTables: false }) {
+		let query = this.#db.selectFrom("sqlite_schema").where("type", "=", "table").where("name", "not like", "sqlite_%").select("name").$castTo();
+		if (!options.withInternalKyselyTables) query = query.where("name", "!=", DEFAULT_MIGRATION_TABLE).where("name", "!=", DEFAULT_MIGRATION_LOCK_TABLE);
+		const tables = await query.execute();
+		return Promise.all(tables.map(({ name }) => this.#getTableMetadata(name)));
+	}
+	async getMetadata(options) {
+		return { tables: await this.getTables(options) };
+	}
+	async #getTableMetadata(table) {
+		const db = this.#db;
+		const autoIncrementCol = (await db.selectFrom("sqlite_master").where("name", "=", table).select("sql").$castTo().execute())[0]?.sql?.split(/[\(\),]/)?.find((it) => it.toLowerCase().includes("autoincrement"))?.split(/\s+/)?.[0]?.replace(/["`]/g, "");
+		return {
+			name: table,
+			columns: (await db.selectFrom(sql`pragma_table_info(${table})`.as("table_info")).select([
+				"name",
+				"type",
+				"notnull",
+				"dflt_value"
+			]).execute()).map((col) => ({
+				name: col.name,
+				dataType: col.type,
+				isNullable: !col.notnull,
+				isAutoIncrementing: col.name === autoIncrementCol,
+				hasDefaultValue: col.dflt_value != null
+			})),
+			isView: true
+		};
+	}
+};
+var BunSqliteQueryCompiler = class extends DefaultQueryCompiler {
+	getCurrentParameterPlaceholder() {
+		return "?";
+	}
+	getLeftIdentifierWrapper() {
+		return "\"";
+	}
+	getRightIdentifierWrapper() {
+		return "\"";
+	}
+	getAutoIncrement() {
+		return "autoincrement";
+	}
+};
+var BunSqliteDialect = class {
+	#config;
+	constructor(config) {
+		this.#config = { ...config };
+	}
+	createDriver() {
+		return new BunSqliteDriver(this.#config);
+	}
+	createQueryCompiler() {
+		return new BunSqliteQueryCompiler();
+	}
+	createAdapter() {
+		return new BunSqliteAdapter();
+	}
+	createIntrospector(db) {
+		return new BunSqliteIntrospector(db);
+	}
+};
+
+//#endregion
+export { BunSqliteDialect };

package/dist/exports/{cli/_virtual/rolldown_runtime.mjs → api/chunk-CyXqrcp_.mjs}

@@ -1,8 +1,14 @@
+import { createRequire } from "node:module";
+
 //#region rolldown:runtime
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __export = (all, symbols) => {
 	let target = {};
 	for (var name in all) {
@@ -31,6 +37,13 @@ var __copyProps = (to, from, except, desc) => {
 	return to;
 };
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __toDynamicImportESM = (isNodeMode) => (mod) => __toESM(mod.default, isNodeMode);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 //#endregion
-export { __export, __reExport };
+export { __require as a, __toESM as c, __reExport as i, __esmMin as n, __toCommonJS as o, __export as r, __toDynamicImportESM as s, __commonJSMin as t };

package/dist/exports/api/conditions-DjBAWfiK.mjs

@@ -0,0 +1,116 @@
+import { At as is, Et as Column, F as Placeholder, H as isSQLWrapper, I as SQL, L as StringChunk, P as Param, R as View, V as isDriverValueEncoder, X as sql, nt as Table } from "./table-6bTIEqON.mjs";
+
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/sql/expressions/conditions.js
+function bindIfParam(value, column) {
+	if (isDriverValueEncoder(column) && !isSQLWrapper(value) && !is(value, Param) && !is(value, Placeholder) && !is(value, Column) && !is(value, Table) && !is(value, View)) return new Param(value, column);
+	return value;
+}
+const eq = (left, right) => {
+	return sql`${left} = ${bindIfParam(right, left)}`;
+};
+const ne = (left, right) => {
+	return sql`${left} <> ${bindIfParam(right, left)}`;
+};
+function and(...unfilteredConditions) {
+	const conditions = unfilteredConditions.filter((c) => c !== void 0);
+	if (conditions.length === 0) return;
+	if (conditions.length === 1) return new SQL(conditions);
+	return new SQL([
+		new StringChunk("("),
+		sql.join(conditions, new StringChunk(" and ")),
+		new StringChunk(")")
+	]);
+}
+function or(...unfilteredConditions) {
+	const conditions = unfilteredConditions.filter((c) => c !== void 0);
+	if (conditions.length === 0) return;
+	if (conditions.length === 1) return new SQL(conditions);
+	return new SQL([
+		new StringChunk("("),
+		sql.join(conditions, new StringChunk(" or ")),
+		new StringChunk(")")
+	]);
+}
+function not(condition) {
+	return sql`not ${condition}`;
+}
+const gt = (left, right) => {
+	return sql`${left} > ${bindIfParam(right, left)}`;
+};
+const gte = (left, right) => {
+	return sql`${left} >= ${bindIfParam(right, left)}`;
+};
+const lt = (left, right) => {
+	return sql`${left} < ${bindIfParam(right, left)}`;
+};
+const lte = (left, right) => {
+	return sql`${left} <= ${bindIfParam(right, left)}`;
+};
+function inArray(column, values) {
+	if (Array.isArray(values)) {
+		if (values.length === 0) return sql`false`;
+		return sql`${column} in ${values.map((v) => bindIfParam(v, column))}`;
+	}
+	return sql`${column} in ${bindIfParam(values, column)}`;
+}
+function notInArray(column, values) {
+	if (Array.isArray(values)) {
+		if (values.length === 0) return sql`true`;
+		return sql`${column} not in ${values.map((v) => bindIfParam(v, column))}`;
+	}
+	return sql`${column} not in ${bindIfParam(values, column)}`;
+}
+function isNull(value) {
+	return sql`${value} is null`;
+}
+function isNotNull(value) {
+	return sql`${value} is not null`;
+}
+function exists(subquery) {
+	return sql`exists ${subquery}`;
+}
+function notExists(subquery) {
+	return sql`not exists ${subquery}`;
+}
+function between(column, min, max) {
+	return sql`${column} between ${bindIfParam(min, column)} and ${bindIfParam(max, column)}`;
+}
+function notBetween(column, min, max) {
+	return sql`${column} not between ${bindIfParam(min, column)} and ${bindIfParam(max, column)}`;
+}
+function like(column, value) {
+	return sql`${column} like ${value}`;
+}
+function notLike(column, value) {
+	return sql`${column} not like ${value}`;
+}
+function ilike(column, value) {
+	return sql`${column} ilike ${value}`;
+}
+function notIlike(column, value) {
+	return sql`${column} not ilike ${value}`;
+}
+function arrayContains(column, values) {
+	if (Array.isArray(values)) {
+		if (values.length === 0) throw new Error("arrayContains requires at least one value");
+		return sql`${column} @> ${sql`${bindIfParam(values, column)}`}`;
+	}
+	return sql`${column} @> ${bindIfParam(values, column)}`;
+}
+function arrayContained(column, values) {
+	if (Array.isArray(values)) {
+		if (values.length === 0) throw new Error("arrayContained requires at least one value");
+		return sql`${column} <@ ${sql`${bindIfParam(values, column)}`}`;
+	}
+	return sql`${column} <@ ${bindIfParam(values, column)}`;
+}
+function arrayOverlaps(column, values) {
+	if (Array.isArray(values)) {
+		if (values.length === 0) throw new Error("arrayOverlaps requires at least one value");
+		return sql`${column} && ${sql`${bindIfParam(values, column)}`}`;
+	}
+	return sql`${column} && ${bindIfParam(values, column)}`;
+}
+
+//#endregion
+export { notInArray as C, notIlike as S, or as T, lte as _, between as a, notBetween as b, exists as c, ilike as d, inArray as f, lt as g, like as h, arrayOverlaps as i, gt as l, isNull as m, arrayContained as n, bindIfParam as o, isNotNull as p, arrayContains as r, eq as s, and as t, gte as u, ne as v, notLike as w, notExists as x, not as y };

package/dist/exports/api/dialect-CUUD24Ge.mjs

@@ -0,0 +1,72 @@
+import { i as SqliteDialect, n as PostgresDialect, r as MysqlDialect, t as MssqlDialect, u as Kysely } from "./esm-_hkVMulx.mjs";
+
+//#region ../../node_modules/.bun/better-auth@1.4.7+f768ad5b9455517d/node_modules/better-auth/dist/adapters/kysely-adapter/dialect.mjs
+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 = async (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 });
+	if ("fileControl" in db) {
+		const { BunSqliteDialect } = await import("./bun-sqlite-dialect-CPpPZa23.mjs");
+		dialect = new BunSqliteDialect({ database: db });
+	}
+	if ("createSession" in db && typeof window === "undefined") {
+		let DatabaseSync = void 0;
+		try {
+			let nodeSqlite = "node:sqlite";
+			({DatabaseSync} = await import(
+				/* @vite-ignore */
+				/* webpackIgnore: true */
+				nodeSqlite
+));
+		} catch (error) {
+			if (error !== null && typeof error === "object" && "code" in error && error.code !== "ERR_UNKNOWN_BUILTIN_MODULE") throw error;
+		}
+		if (DatabaseSync && db instanceof DatabaseSync) {
+			const { NodeSqliteDialect } = await import("./node-sqlite-dialect-Bl5suBxl.mjs");
+			dialect = new NodeSqliteDialect({ database: db });
+		}
+	}
+	return {
+		kysely: dialect ? new Kysely({ dialect }) : null,
+		databaseType,
+		transaction: void 0
+	};
+};
+
+//#endregion
+export { getKyselyDatabaseType as n, createKyselyAdapter as t };

package/dist/exports/api/env-CwT3zhez.mjs

@@ -0,0 +1 @@
+export {  };