@revojs/storage 0.2.65 → 0.3.0

package/dist/index.d.ts

@@ -12,6 +12,9 @@ export type Definition = CheckConstraint | ForeignKeyConstraint | Index | Primar
 export interface Base {
     toSql: () => Sql;
 }
+export interface RunResult {
+    changes: number;
+}
 export interface Query<T = unknown> {
     sql: string;
     parameters: Array<Primitive>;
@@ -180,6 +183,7 @@ export declare class SelectStatement<TSelection = Table | Record<string, Column>
     protected $limit: Sql | undefined;
     protected $offset: Sql | undefined;
     constructor(session: Session, value: TSelection);
+    distinct(): this & Record<"distinct", never>;
     from(table: Table): this & Record<"from", never>;
     leftJoin<TTable extends Table>(table: TTable, on: Chunk): SelectStatement<AppendToSelection<TSelection, TTable, TMode>, TMode extends "partial" ? "partial" : "multiple", AppendToNullabilityMap<TNullability, TTable, "left">>;
     rightJoin<TTable extends Table>(table: TTable, on: Chunk): SelectStatement<AppendToSelection<TSelection, TTable, TMode>, TMode extends "partial" ? "partial" : "multiple", AppendToNullabilityMap<TNullability, TTable, "right">>;
@@ -199,6 +203,11 @@ export declare class InsertStatement<T extends Table = Table> extends Statement<
     constructor(session: Session, table: T);
     values<This extends InsertStatement>(this: This, value: InferInsertModel<T> | Array<InferInsertModel<T>>): This & Record<"values", never>;
     onConflictDoNothing<This extends InsertStatement>(this: This): This & Record<"onConflictDoNothing", never>;
+    onConflictDoUpdate<This extends InsertStatement>(this: This, options: {
+        target: Column | Array<Column>;
+        set: Partial<InferInsertModel<T>>;
+    }): This & Record<"onConflictDoNothing" | "onConflictDoUpdate", never>;
+    protected toConflictUpdate(targets: Array<Column>, updates: Array<Chunk>): Sql<unknown>;
     returning<This extends InsertStatement>(this: This): This & Record<"returning", never>;
 }
 export declare class UpdateStatement<T extends Table = Table> extends Statement<Array<InferSelectModel<T>>> {
@@ -225,7 +234,7 @@ export declare abstract class PreparedQuery {
 }
 export declare abstract class Session {
     transaction<T>(run: (session: Session) => Awaitable<T>): Promise<T>;
-    batch(queries: Array<Query>): Promise<void>;
+    batch(queries: Array<Query>): Promise<Array<RunResult>>;
     run(query: Query): unknown;
     all(query: Query): unknown;
     get(query: Query): unknown;
@@ -277,7 +286,7 @@ export declare abstract class Database<T extends Record<string, Table> = Record<
     abstract update<TValue extends Table>(table: TValue): UpdateStatement<TValue>;
     abstract delete<TValue extends Table>(table: TValue): DeleteStatement<TValue>;
     abstract transaction<TResult>(run: (database: Database<T>) => Awaitable<TResult>): Promise<TResult>;
-    batch(statements: Array<InsertStatement | UpdateStatement | DeleteStatement>): Promise<void>;
+    batch(statements: Array<InsertStatement | UpdateStatement | DeleteStatement | Sql>): Promise<RunResult[]>;
 }
 export declare abstract class Table<TName extends string = string, TColumns extends Record<string, Column> = Record<string, Column>> {
     readonly $name: TName;
@@ -312,6 +321,15 @@ export declare abstract class Column<TDataType = unknown> {
     toMeta(): ColumnMeta;
     abstract toSqlType(): string;
 }
+export declare class Expression<TDataType = unknown> extends Column<TDataType> {
+    $expression: Sql;
+    $source: Column | undefined;
+    constructor(expression: Sql, source?: Column);
+    fromDriverValue(value: unknown): TDataType;
+    toSql(): Sql<unknown>;
+    toSqlName(): Sql<unknown>;
+    toSqlType(): string;
+}
 export declare class UniqueConstraint {
     $columns: Array<Column>;
     constructor(...columns: Array<Column>);
@@ -369,6 +387,15 @@ export declare function and<T>(...chunks: Array<Chunk>): Sql<T>;
 export declare function or<T>(...chunks: Array<Chunk>): Sql<T>;
 export declare function asc<T>(chunk: Chunk): Sql<T>;
 export declare function desc<T>(chunk: Chunk): Sql<T>;
+export declare function expression<T>(value: Sql, source?: Column): Expression<T>;
+export declare function count(chunk?: Chunk): Expression<number> & Record<"notNull", never>;
+export declare function countDistinct(column: Column): Expression<number> & Record<"notNull", never>;
+export declare function max<TColumn extends Column>(column: TColumn): Expression<Data<TColumn>>;
+export declare function min<TColumn extends Column>(column: TColumn): Expression<Data<TColumn>>;
+export declare function sum(column: Column): Expression<number>;
+export declare function coalesce<TColumn extends Column>(column: TColumn, fallback: Data<TColumn>): Expression<Data<TColumn>> & Record<"notNull", never>;
+export declare function chunkValues<T>(values: Array<T>, size: number): T[][];
+export declare function toRunResult(value: unknown): RunResult;
 export declare function mergeTable<TTable extends Table, TColumns extends Record<string, Column>>(table: TTable, columns: TColumns, definitions?: (columns: TTable["$columns"] & TColumns) => Array<Definition>): TTable & TColumns & {
     readonly $columns: TTable["$columns"] & TColumns;
 };

package/dist/index.js

@@ -86,6 +86,10 @@ var SelectStatement = class extends Statement {
 		this.$selection = combine(this.$fields.map(([, column]) => column), ", ");
 		this.push(sql`SELECT ${this.$selection}`);
 	}
+	distinct() {
+		this.$chunks[0] = sql`SELECT DISTINCT ${this.$selection}`;
+		return this;
+	}
 	from(table) {
 		this.push(sql`FROM ${table}`);
 		return this;
@@ -210,6 +214,17 @@ var InsertStatement = class extends Statement {
 		this.push(sql`ON CONFLICT DO NOTHING`);
 		return this;
 	}
+	onConflictDoUpdate(options) {
+		const columns = this.$table.$columns;
+		const targets = Array.isArray(options.target) ? options.target : [options.target];
+		const updates = new Array();
+		for (const [key, value] of Object.entries(options.set)) updates.push(sql`${columns[key].toSqlName()} = ${toParameter(columns[key], value ?? null)}`);
+		this.push(this.toConflictUpdate(targets, updates));
+		return this;
+	}
+	toConflictUpdate(targets, updates) {
+		return sql`ON CONFLICT (${combine(targets.map((column) => column.toSqlName()), ", ")}) DO UPDATE SET ${combine(updates, ", ")}`;
+	}
 	returning() {
 		this.push(sql`RETURNING ${combine(this.$fields.map(([, column]) => column.toSqlName()), ", ")}`);
 		return this;
@@ -264,8 +279,10 @@ var Session = class {
 		throw new Error("This storage provider does not support interactive transactions.");
 	}
 	async batch(queries) {
-		await this.transaction(async (session) => {
-			for (const query of queries) await session.run(query);
+		return await this.transaction(async (session) => {
+			const results = new Array();
+			for (const query of queries) results.push(toRunResult(await session.run(query)));
+			return results;
 		});
 	}
 	run(query) {
@@ -598,7 +615,10 @@ var Database = class {
 		};
 	}
 	async batch(statements) {
-		if (statements.length > 0) await this.$session.batch(statements.map((statement) => statement.toQuery()));
+		if (statements.length === 0) return [];
+		const queries = new Array();
+		for (const statement of statements) queries.push(statement.toQuery());
+		return await this.$session.batch(queries);
 	}
 };
 var Table = class {
@@ -700,6 +720,28 @@ var Column = class {
 		};
 	}
 };
+var Expression = class extends Column {
+	$expression;
+	$source;
+	constructor(expression, source) {
+		super("");
+		this.$expression = expression;
+		this.$source = source;
+	}
+	fromDriverValue(value) {
+		if (this.$source) return this.$source.fromDriverValue(value);
+		return value;
+	}
+	toSql() {
+		return this.$expression;
+	}
+	toSqlName() {
+		return this.$expression;
+	}
+	toSqlType() {
+		return "";
+	}
+};
 var UniqueConstraint = class {
 	$columns;
 	constructor(...columns) {
@@ -874,6 +916,39 @@ function asc(chunk) {
 function desc(chunk) {
 	return sql`${chunk} DESC`;
 }
+function expression(value, source) {
+	return new Expression(value, source);
+}
+function count(chunk) {
+	return new Expression(sql`COUNT(${chunk ?? new Sql("*")})`).notNull();
+}
+function countDistinct(column) {
+	return new Expression(sql`COUNT(DISTINCT ${column})`).notNull();
+}
+function max(column) {
+	return new Expression(sql`MAX(${column})`, column);
+}
+function min(column) {
+	return new Expression(sql`MIN(${column})`, column);
+}
+function sum(column) {
+	return new Expression(sql`SUM(${column})`);
+}
+function coalesce(column, fallback) {
+	return new Expression(sql`COALESCE(${column}, ${toParameter(column, fallback)})`, column).notNull();
+}
+function chunkValues(values, size) {
+	const chunks = new Array();
+	for (let index = 0; index < values.length; index += size) chunks.push(values.slice(index, index + size));
+	return chunks;
+}
+function toRunResult(value) {
+	if (typeof value === "object" && value !== null) {
+		if ("changes" in value && typeof value.changes === "number") return { changes: value.changes };
+		if ("meta" in value && typeof value.meta === "object" && value.meta !== null && "changes" in value.meta && typeof value.meta.changes === "number") return { changes: value.meta.changes };
+	}
+	return { changes: 0 };
+}
 function mergeTable(table, columns, definitions) {
 	const mergedColumns = {};
 	const names = /* @__PURE__ */ new Set();
@@ -945,4 +1020,4 @@ function useStorage(scope, scopeName) {
 }
 var STORAGE_CONTEXT = defineContext("STORAGE_CONTEXT");
 //#endregion
-export { CheckConstraint, Column, Database, DeleteStatement, ForeignKeyConstraint, Index, InsertStatement, Migration, Parameter, PreparedQuery, PrimaryKeyConstraint, STORAGE_CONTEXT, SelectStatement, Session, Sql, Statement, Table, UniqueConstraint, UniqueIndex, UpdateStatement, and, asc, between, combine, contains, desc, equals, exists, greater, greaterEquals, like, lower, lowerEquals, mergeTable, not, nullish, or, sql, toParameter, useReferenceStorage, useStorage, useStorageContext, useStorageProvider };
+export { CheckConstraint, Column, Database, DeleteStatement, Expression, ForeignKeyConstraint, Index, InsertStatement, Migration, Parameter, PreparedQuery, PrimaryKeyConstraint, STORAGE_CONTEXT, SelectStatement, Session, Sql, Statement, Table, UniqueConstraint, UniqueIndex, UpdateStatement, and, asc, between, chunkValues, coalesce, combine, contains, count, countDistinct, desc, equals, exists, expression, greater, greaterEquals, like, lower, lowerEquals, max, mergeTable, min, not, nullish, or, sql, sum, toParameter, toRunResult, useReferenceStorage, useStorage, useStorageContext, useStorageProvider };

package/dist/protocols/mysql.d.ts

@@ -1,5 +1,5 @@
 import type { Awaitable } from "revojs/shared";
-import { CheckConstraint, Column, Database, DeleteStatement, ForeignKeyConstraint, Index, InsertStatement, Migration, PrimaryKeyConstraint, SelectStatement, Sql, Table, UniqueConstraint, UniqueIndex, UpdateStatement, type Definition, type DeleteConstraintChange, type DeleteIndexChange, type Session, type UpdateColumnChange } from "../index";
+import { CheckConstraint, Column, Database, DeleteStatement, ForeignKeyConstraint, Index, InsertStatement, Migration, PrimaryKeyConstraint, SelectStatement, Sql, Table, UniqueConstraint, UniqueIndex, UpdateStatement, type Chunk, type Definition, type DeleteConstraintChange, type DeleteIndexChange, type Session, type UpdateColumnChange } from "../index";
 export interface CharOptions {
     length?: number;
 }
@@ -122,6 +122,7 @@ export declare class MysqlUniqueIndex extends UniqueIndex {
 export declare class MysqlSelectStatement<T extends Table | Record<string, Column>> extends SelectStatement<T> {
 }
 export declare class MysqlInsertStatement<T extends Table> extends InsertStatement<T> {
+    protected toConflictUpdate(_targets: Array<Column>, updates: Array<Chunk>): Sql<unknown>;
 }
 export declare class MysqlUpdateStatement<T extends Table> extends UpdateStatement<T> {
 }

package/dist/protocols/mysql.js

@@ -1,4 +1,4 @@
-import { CheckConstraint, Column, Database, DeleteStatement, ForeignKeyConstraint, Index, InsertStatement, Migration, PrimaryKeyConstraint, SelectStatement, Sql, Table, UniqueConstraint, UniqueIndex, UpdateStatement } from "../index.js";
+import { CheckConstraint, Column, Database, DeleteStatement, ForeignKeyConstraint, Index, InsertStatement, Migration, PrimaryKeyConstraint, SelectStatement, Sql, Table, UniqueConstraint, UniqueIndex, UpdateStatement, combine, sql } from "../index.js";
 //#region src/protocols/mysql.ts
 var MysqlColumn = class extends Column {
 	autoincrement() {
@@ -189,7 +189,11 @@ var MysqlUniqueIndex = class extends UniqueIndex {
 	}
 };
 var MysqlSelectStatement = class extends SelectStatement {};
-var MysqlInsertStatement = class extends InsertStatement {};
+var MysqlInsertStatement = class extends InsertStatement {
+	toConflictUpdate(_targets, updates) {
+		return sql`ON DUPLICATE KEY UPDATE ${combine(updates, ", ")}`;
+	}
+};
 var MysqlUpdateStatement = class extends UpdateStatement {};
 var MysqlDeleteStatement = class extends DeleteStatement {};
 var MysqlTable = class extends Table {

package/dist/providers/d1.d.ts

@@ -1,6 +1,6 @@
 import type { D1Database, D1DatabaseSession, D1PreparedStatement } from "@cloudflare/workers-types";
 import type { Awaitable, Primitive } from "revojs/shared";
-import { PreparedQuery, Session, type Query } from "../index";
+import { PreparedQuery, Session, type Query, type RunResult } from "../index";
 import { SqliteDatabase, type SqliteTable } from "../protocols/sqlite";
 export declare class D1PreparedQuery extends PreparedQuery {
     protected $statement: D1PreparedStatement;
@@ -14,7 +14,9 @@ export declare class D1Session extends Session {
     protected $client: D1Database | D1DatabaseSession;
     constructor(client: D1Database | D1DatabaseSession);
     transaction<T>(run: (session: Session) => Awaitable<T>): Promise<T>;
-    batch(queries: Array<Query>): Promise<void>;
+    batch(queries: Array<Query>): Promise<RunResult[]>;
     prepareQuery(query: Query): D1PreparedQuery;
 }
+export declare function checkParameters(query: Query): void;
 export declare function d1<T extends Record<string, SqliteTable>>(client: D1Database | D1DatabaseSession, schema: T): SqliteDatabase<T>;
+export declare const D1_MAX_PARAMETERS = 100;

package/dist/providers/d1.js

@@ -1,4 +1,4 @@
-import { PreparedQuery, Session } from "../index.js";
+import { PreparedQuery, Session, toRunResult } from "../index.js";
 import { SqliteDatabase } from "../protocols/sqlite.js";
 //#region src/providers/d1.ts
 var D1PreparedQuery = class extends PreparedQuery {
@@ -30,14 +30,26 @@ var D1Session = class extends Session {
 		throw new Error("Cloudflare D1 does not support interactive transactions; use its atomic batch API instead.");
 	}
 	async batch(queries) {
-		await this.$client.batch(queries.map((query) => this.$client.prepare(query.sql).bind(...query.parameters)));
+		const statements = new Array();
+		for (const query of queries) {
+			checkParameters(query);
+			statements.push(this.$client.prepare(query.sql).bind(...query.parameters));
+		}
+		const results = new Array();
+		for (const result of await this.$client.batch(statements)) results.push(toRunResult(result));
+		return results;
 	}
 	prepareQuery(query) {
+		checkParameters(query);
 		return new D1PreparedQuery(query, this.$client.prepare(query.sql));
 	}
 };
+function checkParameters(query) {
+	if (query.parameters.length > 100) throw new RangeError(`Cloudflare D1 binds at most 100 parameters per statement, this one binds ${query.parameters.length}. Split the values with chunkValues().`);
+}
 function d1(client, schema) {
 	return new SqliteDatabase(new D1Session(client), schema);
 }
+var D1_MAX_PARAMETERS = 100;
 //#endregion
-export { D1PreparedQuery, D1Session, d1 };
+export { D1PreparedQuery, D1Session, D1_MAX_PARAMETERS, checkParameters, d1 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@revojs/storage",
-    "version": "0.2.65",
+    "version": "0.3.0",
     "license": "MIT",
     "repository": {
         "type": "git",
@@ -37,10 +37,10 @@
         "watch": "vite build --watch"
     },
     "dependencies": {
-        "revojs": "*"
+        "revojs": "0.3.0"
     },
     "devDependencies": {
-        "@revojs/tsconfig": "*"
+        "@revojs/tsconfig": "0.3.0"
     },
     "optionalDependencies": {
         "@cloudflare/workers-types": "^5.20261009.1",