@revojs/storage 0.1.58

package/dist/protocols/sqlite.js

@@ -0,0 +1,217 @@
+import { CheckConstraint, Column, Database, DeleteStatement, ForeignKeyConstraint, Index, InsertStatement, Migration, PrimaryKeyConstraint, SelectStatement, Table, UniqueConstraint, UniqueIndex, UpdateStatement, combine, sql } from "../index.js";
+//#region src/protocols/sqlite.ts
+var SqliteColumn = class extends Column {
+	type() {
+		return this;
+	}
+};
+var BlobColumn = class extends SqliteColumn {
+	toSqlType() {
+		return "blob";
+	}
+};
+var IntegerColumn = class extends SqliteColumn {
+	$options;
+	constructor(name, options) {
+		super(name);
+		this.$options = options;
+	}
+	toSqlType() {
+		return "integer";
+	}
+	toMeta() {
+		return {
+			...super.toMeta(),
+			mode: this.$options?.mode
+		};
+	}
+	fromDriverValue(value) {
+		if (this.$options?.mode === "timestamp") return typeof value === "string" ? new Date(value.replaceAll("\"", "")) : /* @__PURE__ */ new Date(Number(value) * 1e3);
+		if (this.$options?.mode === "timestamp_ms") return typeof value === "string" ? new Date(value.replaceAll("\"", "")) : new Date(Number(value));
+		if (this.$options?.mode === "boolean") return Number(value) === 1;
+		return Number(value);
+	}
+	toDriverValue(value) {
+		if (this.$options?.mode === "timestamp") return typeof value === "number" ? value : Math.floor(value.getTime() / 1e3);
+		if (this.$options?.mode === "timestamp_ms") return typeof value === "number" ? value : value.getTime();
+		if (this.$options?.mode === "boolean") return value ? 1 : 0;
+		return value;
+	}
+};
+var NumericColumn = class extends SqliteColumn {
+	toSqlType() {
+		return "numeric";
+	}
+};
+var RealColumn = class extends SqliteColumn {
+	toSqlType() {
+		return "real";
+	}
+};
+var TextColumn = class extends SqliteColumn {
+	$options;
+	constructor(name, options) {
+		super(name);
+		this.$options = options;
+	}
+	toSqlType() {
+		return "text";
+	}
+	toMeta() {
+		return {
+			...super.toMeta(),
+			mode: this.$options?.mode
+		};
+	}
+	fromDriverValue(value) {
+		if (this.$options?.mode === "json") return JSON.parse(String(value));
+		return value;
+	}
+	toDriverValue(value) {
+		if (this.$options?.mode === "json") return JSON.stringify(value);
+		return value;
+	}
+};
+var SqliteUniqueConstraint = class extends UniqueConstraint {};
+var SqliteCheckConstraint = class extends CheckConstraint {};
+var SqlitePrimaryKeyConstraint = class extends PrimaryKeyConstraint {};
+var SqliteForeignKeyConstraint = class extends ForeignKeyConstraint {};
+var SqliteIndex = class extends Index {
+	where() {
+		return this;
+	}
+};
+var SqliteUniqueIndex = class extends UniqueIndex {
+	where() {
+		return this;
+	}
+};
+var SqliteSelectStatement = class extends SelectStatement {
+	fullJoin(table, on) {
+		this.push(sql`FULL JOIN ${table} ON ${on}`);
+		if (this.$value instanceof Table) {
+			this.$selection.push(", ", combine(Object.values(table.$columns), ", "));
+			this.$baseNullable = true;
+			this.$joins.forEach((join) => join.nullable = true);
+			this.$joins.push({
+				table,
+				nullable: true
+			});
+		}
+		return this;
+	}
+};
+var SqliteInsertStatement = class extends InsertStatement {};
+var SqliteUpdateStatement = class extends UpdateStatement {};
+var SqliteDeleteStatement = class extends DeleteStatement {};
+var SqliteTable = class extends Table {};
+var SqliteMigration = class extends Migration {
+	$dialect = "sqlite";
+	render({ changes, current }) {
+		const rebuilds = /* @__PURE__ */ new Map();
+		const direct = new Array();
+		for (const change of changes) {
+			if (change.kind === "updateColumn" && change.before.name === change.after.name && change.before.type === change.after.type && change.before.notNull === change.after.notNull && this.equals(this.columnConstraints(change.before), this.columnConstraints(change.after))) continue;
+			if (change.kind === "updateColumn" || change.kind === "deleteColumn" || change.kind === "createConstraint" || change.kind === "deleteConstraint" || change.kind === "createColumn" && this.columnConstraints(change.column).length > 0) {
+				const createdColumns = rebuilds.get(change.table) ?? /* @__PURE__ */ new Set();
+				if (change.kind === "createColumn") createdColumns.add(change.column.name);
+				rebuilds.set(change.table, createdColumns);
+			} else direct.push(change);
+		}
+		const statements = new Array();
+		if (rebuilds.size > 0) statements.push("PRAGMA foreign_keys = OFF;");
+		for (const change of direct) {
+			if (typeof change.table === "string" && rebuilds.has(change.table)) continue;
+			statements.push(...this.renderChange(change));
+		}
+		for (const [name, createdColumns] of rebuilds) {
+			const table = current.tables.find((value) => value.name === name);
+			if (!table) throw new Error(`Unable to rebuild missing SQLite table "${name}"`);
+			const temporaryName = `__revojs_${table.name}_new`;
+			const columns = Object.values(table.columns).filter((column) => !createdColumns.has(column.name)).map((column) => column.name);
+			statements.push(...this.toCreateTableChange({
+				kind: "createTable",
+				table
+			}, temporaryName));
+			if (columns.length > 0) statements.push(`INSERT INTO ${this.quoteIdentifier(temporaryName)} (${this.quoteIdentifiers(columns)}) SELECT ${this.quoteIdentifiers(columns)} FROM ${this.quoteIdentifier(table.name)};`);
+			statements.push(`DROP TABLE ${this.quoteIdentifier(table.name)};`, this.alterTable(temporaryName, `RENAME TO ${this.quoteIdentifier(table.name)}`));
+			for (const definition of table.definitions) if (definition.kind === "index" || definition.kind === "uniqueIndex") statements.push(...this.toCreateIndexChange({
+				kind: "createIndex",
+				table: table.name,
+				index: definition
+			}));
+		}
+		if (rebuilds.size > 0) statements.push("PRAGMA foreign_keys = ON;");
+		return statements;
+	}
+	toUpdateColumnChange(change) {
+		throw new Error(`SQLite column migration for "${change.table}.${change.before.name}" to "${change.after.name}" requires a rebuild`);
+	}
+	toDeleteConstraintChange(change) {
+		throw new Error(`SQLite constraint migration for "${this.constraintName(change.table, change.constraint)}" requires a rebuild`);
+	}
+	quoteIdentifier(value) {
+		return `\`${value.replaceAll("`", "``")}\``;
+	}
+	serializeLiteral(value) {
+		if (typeof value === "boolean") return value ? "1" : "0";
+		return super.serializeLiteral(value);
+	}
+};
+var SqliteDatabase = class extends Database {
+	$migration;
+	constructor(session, schema) {
+		super(session, schema);
+		this.$migration = new SqliteMigration();
+	}
+	select(value) {
+		return new SqliteSelectStatement(this.$session, value);
+	}
+	insert(table) {
+		return new SqliteInsertStatement(this.$session, table);
+	}
+	update(table) {
+		return new SqliteUpdateStatement(this.$session, table);
+	}
+	delete(table) {
+		return new SqliteDeleteStatement(this.$session, table);
+	}
+};
+function blob(name) {
+	return new BlobColumn(name);
+}
+function integer(name, options) {
+	return new IntegerColumn(name, options);
+}
+function numeric(name) {
+	return new NumericColumn(name);
+}
+function real(name) {
+	return new RealColumn(name);
+}
+function text(name, options) {
+	return new TextColumn(name, options);
+}
+function unique(...columns) {
+	return new SqliteUniqueConstraint(...columns);
+}
+function check(value) {
+	return new SqliteCheckConstraint(value);
+}
+function primaryKey(...columns) {
+	return new SqlitePrimaryKeyConstraint(...columns);
+}
+function foreignKey(columns, foreignColumns) {
+	return new SqliteForeignKeyConstraint(columns, foreignColumns);
+}
+function index(...columns) {
+	return new SqliteIndex(...columns);
+}
+function uniqueIndex(...columns) {
+	return new SqliteUniqueIndex(...columns);
+}
+function table(name, columns, definitions) {
+	return Object.assign(new SqliteTable(name, columns, definitions?.(columns) ?? []), columns);
+}
+//#endregion
+export { BlobColumn, IntegerColumn, NumericColumn, RealColumn, SqliteCheckConstraint, SqliteColumn, SqliteDatabase, SqliteDeleteStatement, SqliteForeignKeyConstraint, SqliteIndex, SqliteInsertStatement, SqliteMigration, SqlitePrimaryKeyConstraint, SqliteSelectStatement, SqliteTable, SqliteUniqueConstraint, SqliteUniqueIndex, SqliteUpdateStatement, TextColumn, blob, check, foreignKey, index, integer, numeric, primaryKey, real, table, text, unique, uniqueIndex };

package/dist/providers/bun-sqlite.d.ts

@@ -0,0 +1,18 @@
+import type { Database, Statement } from "bun:sqlite";
+import type { Primitive } from "revojs/shared";
+import { PreparedQuery, Session, type Query } from "../index";
+import { SqliteDatabase, type SqliteTable } from "../protocols/sqlite";
+export declare class BunSqlitePreparedQuery extends PreparedQuery {
+    protected $statement: Statement;
+    constructor(query: Query, statement: Statement);
+    run(parameters: Array<Primitive>): import("bun:sqlite").Changes;
+    all(parameters: Array<Primitive>): (string | number | bigint | boolean | Uint8Array<ArrayBufferLike>)[][];
+    get(parameters: Array<Primitive>): (string | number | bigint | boolean | Uint8Array<ArrayBufferLike>)[];
+    values(parameters: Array<Primitive>): (string | number | bigint | boolean | Uint8Array<ArrayBufferLike>)[][];
+}
+export declare class BunSqliteSession extends Session {
+    protected $client: Database;
+    constructor(client: Database);
+    prepareQuery(query: Query): BunSqlitePreparedQuery;
+}
+export declare function bunSqlite<T extends Record<string, SqliteTable>>(client: Database, schema: T): SqliteDatabase<T>;

package/dist/providers/bun-sqlite.js

@@ -0,0 +1,37 @@
+import { PreparedQuery, Session } from "../index.js";
+import { SqliteDatabase } from "../protocols/sqlite.js";
+//#region src/providers/bun-sqlite.ts
+var BunSqlitePreparedQuery = class extends PreparedQuery {
+	$statement;
+	constructor(query, statement) {
+		super(query);
+		this.$statement = statement;
+	}
+	run(parameters) {
+		return this.$statement.run(...parameters);
+	}
+	all(parameters) {
+		return this.$statement.values(...parameters);
+	}
+	get(parameters) {
+		return this.$statement.values(...parameters)[0];
+	}
+	values(parameters) {
+		return this.$statement.values(...parameters);
+	}
+};
+var BunSqliteSession = class extends Session {
+	$client;
+	constructor(client) {
+		super();
+		this.$client = client;
+	}
+	prepareQuery(query) {
+		return new BunSqlitePreparedQuery(query, this.$client.prepare(query.sql));
+	}
+};
+function bunSqlite(client, schema) {
+	return new SqliteDatabase(new BunSqliteSession(client), schema);
+}
+//#endregion
+export { BunSqlitePreparedQuery, BunSqliteSession, bunSqlite };

package/dist/providers/d1.d.ts

@@ -0,0 +1,18 @@
+import type { D1Database, D1DatabaseSession, D1PreparedStatement } from "@cloudflare/workers-types";
+import type { Primitive } from "revojs/shared";
+import { PreparedQuery, Session, type Query } from "../index";
+import { SqliteDatabase, type SqliteTable } from "../protocols/sqlite";
+export declare class D1PreparedQuery extends PreparedQuery {
+    protected $statement: D1PreparedStatement;
+    constructor(query: Query, statement: D1PreparedStatement);
+    run(parameters: Array<Primitive>): Promise<import("@cloudflare/workers-types").D1Result<Record<string, unknown>>>;
+    all(parameters: Array<Primitive>): Promise<unknown[][]>;
+    get(parameters: Array<Primitive>): Promise<unknown[]>;
+    values(parameters: Array<Primitive>): Promise<unknown[][]>;
+}
+export declare class D1Session extends Session {
+    protected $client: D1Database | D1DatabaseSession;
+    constructor(client: D1Database | D1DatabaseSession);
+    prepareQuery(query: Query): D1PreparedQuery;
+}
+export declare function d1<T extends Record<string, SqliteTable>>(client: D1Database | D1DatabaseSession, schema: T): SqliteDatabase<T>;

package/dist/providers/d1.js

@@ -0,0 +1,37 @@
+import { PreparedQuery, Session } from "../index.js";
+import { SqliteDatabase } from "../protocols/sqlite.js";
+//#region src/providers/d1.ts
+var D1PreparedQuery = class extends PreparedQuery {
+	$statement;
+	constructor(query, statement) {
+		super(query);
+		this.$statement = statement;
+	}
+	run(parameters) {
+		return this.$statement.bind(...parameters).run();
+	}
+	all(parameters) {
+		return this.$statement.bind(...parameters).raw();
+	}
+	get(parameters) {
+		return this.$statement.bind(...parameters).raw().then((rows) => rows[0]);
+	}
+	values(parameters) {
+		return this.$statement.bind(...parameters).raw();
+	}
+};
+var D1Session = class extends Session {
+	$client;
+	constructor(client) {
+		super();
+		this.$client = client;
+	}
+	prepareQuery(query) {
+		return new D1PreparedQuery(query, this.$client.prepare(query.sql));
+	}
+};
+function d1(client, schema) {
+	return new SqliteDatabase(new D1Session(client), schema);
+}
+//#endregion
+export { D1PreparedQuery, D1Session, d1 };

package/dist/types/index.d.ts

@@ -0,0 +1,14 @@
+declare module "#config/storage" {
+    import type { StorageConfig } from "@revojs/storage/module";
+
+    const config: StorageConfig;
+    export default config;
+}
+
+declare module "#storage" {
+    import type { Database } from "../index";
+    import type { Scope, Source } from "revojs";
+
+    const entries: Source<(scope: Scope) => Database>;
+    export default entries;
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+    "name": "@revojs/storage",
+    "version": "0.1.58",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/tellua/revojs.git"
+    },
+    "files": [
+        "dist"
+    ],
+    "type": "module",
+    "main": "./dist/index.js",
+    "module": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        },
+        "./protocols/*": {
+            "types": "./dist/protocols/*.d.ts",
+            "import": "./dist/protocols/*.js"
+        },
+        "./providers/*": {
+            "types": "./dist/providers/*.d.ts",
+            "import": "./dist/providers/*.js"
+        },
+        "./module": {
+            "types": "./dist/module/index.d.ts",
+            "import": "./dist/module/index.js"
+        }
+    },
+    "scripts": {
+        "build": "vite build",
+        "watch": "vite build --watch"
+    },
+    "dependencies": {
+        "revojs": "*"
+    },
+    "devDependencies": {
+        "@revojs/tsconfig": "*"
+    },
+    "optionalDependencies": {
+        "@cloudflare/workers-types": "^5.20260911.1",
+        "@types/bun": "^1.4.2"
+    }
+}