@revojs/storage 0.1.58

package/dist/commands/generate.d.ts

@@ -0,0 +1,8 @@
+declare const _default: import("revojs/module").Command<{
+    readonly directory: {
+        readonly type: "string";
+        readonly short: "d";
+        readonly description: "Migration output directory";
+    };
+}>;
+export default _default;

package/dist/commands/generate.js

@@ -0,0 +1,48 @@
+import { VARIABLE_CONTEXT } from "revojs";
+import storage from "#storage";
+import { defineCommand } from "revojs/module";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
+import { join, resolve } from "path";
+import { loadEnv } from "vite";
+//#region src/commands/generate.ts
+var generate_default = defineCommand({
+	description: "Generate migration files from the storage schema",
+	arguments: { directory: {
+		type: "string",
+		short: "d",
+		description: "Migration output directory"
+	} },
+	async run({ arguments: { directory: output = "migrations" }, environment }) {
+		const databases = Object.values(storage).flatMap((source) => Object.entries(source));
+		if (databases.length === 0) {
+			console.log("No storage databases found.");
+			return;
+		}
+		const scope = {
+			hooks: {},
+			context: { [VARIABLE_CONTEXT]: loadEnv(environment.config.mode, environment.config.envDir, "") }
+		};
+		for (const [name, load] of databases) {
+			const database = (await load())(scope);
+			const current = database.toMeta();
+			const directory = resolve(output, name);
+			const snapshot = (existsSync(directory) ? readdirSync(directory) : []).sort().reverse().map((entry) => join(directory, entry, "meta.json")).find((path) => existsSync(path));
+			const changes = database.$migration.diff(snapshot ? JSON.parse(readFileSync(snapshot, "utf8")) : void 0, current);
+			if (changes.length === 0) {
+				console.log(`No schema changes detected for "${name}".`);
+				continue;
+			}
+			const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/\D/g, "").slice(0, 14);
+			let order = timestamp;
+			for (let index = 2; existsSync(join(directory, order)); index++) order = `${timestamp}-${index}`;
+			const target = join(directory, order);
+			const statements = database.$migration.toSql(changes, current);
+			mkdirSync(target, { recursive: true });
+			writeFileSync(join(target, "meta.json"), `${JSON.stringify(current, null, 4)}\n`);
+			writeFileSync(join(target, "migration.sql"), statements.length ? `${statements.join("\n\n")}\n` : "");
+			console.log(`Created migration "${name}/${order}" with ${changes.length} change(s).`);
+		}
+	}
+});
+//#endregion
+export { generate_default as default };

package/dist/index.d.ts

@@ -0,0 +1,360 @@
+import { type Scope, type Source, type SourceScope, type SourceValue } from "revojs";
+import type { Primitive } from "revojs/shared";
+export type DefaultValue<T> = undefined | T | (() => T);
+export type References = undefined | (() => Column);
+export type ReferentialAction = "cascade" | "restrict" | "no action" | "set null" | "set default";
+export interface ReferentialActions {
+    onDelete?: ReferentialAction;
+    onUpdate?: ReferentialAction;
+}
+export type Chunk = Primitive | Parameter | Sql | Table | Column;
+export type Definition = CheckConstraint | ForeignKeyConstraint | Index | PrimaryKeyConstraint | UniqueConstraint | UniqueIndex;
+export interface Base {
+    toSql: () => Sql;
+}
+export interface Query<T = unknown> {
+    sql: string;
+    parameters: Array<Primitive>;
+}
+export type IsNotNull<T> = T extends Record<"notNull", never> | Record<"primaryKey", never> ? true : false;
+export type HasDefault<T> = T extends Record<"default", never> ? true : false;
+export type IsRequired<T> = HasDefault<T> extends true ? false : IsNotNull<T>;
+export type Data<T> = T extends Record<"$type", infer TData> ? TData : T extends Column<infer TData> ? TData : never;
+export type SelectValue<T> = IsNotNull<T> extends true ? Data<T> : Data<T> | null;
+export type InferColumns<T> = {
+    [Key in keyof T as T[Key] extends Column ? Key : never]: SelectValue<T[Key]>;
+};
+export type RequiredKeys<T> = {
+    [Key in keyof InferColumns<T>]-?: IsRequired<T[Key]> extends true ? Key : never;
+}[keyof InferColumns<T>];
+export type InferModelFromColumns<T, TMode extends "select" | "insert" = "select"> = TMode extends "insert" ? Partial<InferColumns<T>> & Pick<InferColumns<T>, RequiredKeys<T>> : InferColumns<T>;
+export type InferSelectModel<T extends Table> = InferModelFromColumns<T>;
+export type InferInsertModel<T extends Table> = InferModelFromColumns<T, "insert">;
+export type SelectMode = "partial" | "single" | "multiple";
+export type JoinType = "left" | "right" | "inner" | "cross" | "full";
+export type SelectResult<TSelection, TMode extends SelectMode, TNullability extends Record<string, boolean>> = TMode extends "partial" ? InferColumns<TSelection> : TMode extends "single" ? TSelection extends Table ? InferSelectModel<TSelection> : never : {
+    [Key in keyof TSelection]: TSelection[Key] extends Table ? Key extends keyof TNullability ? TNullability[Key] extends true ? InferSelectModel<TSelection[Key]> | null : InferSelectModel<TSelection[Key]> : never : never;
+};
+export type AppendToSelection<TSelection, TTable extends Table, TMode extends SelectMode> = TMode extends "partial" ? TSelection : TMode extends "single" ? TSelection extends Table ? Record<TSelection["$name"], TSelection> & Record<TTable["$name"], TTable> : never : TSelection & Record<TTable["$name"], TTable>;
+export type AppendToNullabilityMap<TNullability extends Record<string, boolean>, TTable extends Table, TJoinType extends JoinType> = TJoinType extends "left" ? TNullability & Record<TTable["$name"], true> : TJoinType extends "right" ? {
+    [Key in keyof TNullability]: true;
+} & Record<TTable["$name"], false> : TJoinType extends "full" ? {
+    [Key in keyof TNullability]: true;
+} & Record<TTable["$name"], true> : TNullability & Record<TTable["$name"], false>;
+export interface PrimaryKeyConstraintMeta {
+    kind: "primaryKey";
+    columns: Array<string>;
+}
+export interface UniqueConstraintMeta {
+    kind: "unique";
+    columns: Array<string>;
+}
+export interface ForeignKeyConstraintMeta {
+    kind: "foreignKey";
+    columns: Array<string>;
+    foreignTable: string;
+    foreignColumns: Array<string>;
+    onDelete?: ReferentialAction;
+    onUpdate?: ReferentialAction;
+}
+export interface CheckConstraintMeta {
+    kind: "check";
+    sql: string;
+    parameters: Array<string | number | boolean | null>;
+}
+export interface IndexMeta {
+    kind: "index";
+    columns: Array<string>;
+}
+export interface UniqueIndexMeta {
+    kind: "uniqueIndex";
+    columns: Array<string>;
+}
+export type ConstraintMeta = PrimaryKeyConstraintMeta | UniqueConstraintMeta | ForeignKeyConstraintMeta | CheckConstraintMeta;
+export type IndexDefinitionMeta = IndexMeta | UniqueIndexMeta;
+export type DefinitionMeta = ConstraintMeta | IndexDefinitionMeta;
+export interface ColumnMeta {
+    name: string;
+    type: string;
+    notNull: boolean;
+    primaryKey: boolean;
+    unique: boolean;
+    references?: ReferenceMeta;
+}
+export interface ReferenceMeta {
+    table: string;
+    column: string;
+    onDelete?: ReferentialAction;
+    onUpdate?: ReferentialAction;
+}
+export interface TableMeta {
+    name: string;
+    columns: Record<string, ColumnMeta>;
+    definitions: Array<DefinitionMeta>;
+}
+export interface DatabaseMeta {
+    dialect: string;
+    tables: Array<TableMeta>;
+}
+export interface CreateTableChange {
+    kind: "createTable";
+    table: TableMeta;
+}
+export interface DeleteTableChange {
+    kind: "deleteTable";
+    table: TableMeta;
+}
+export interface CreateColumnChange {
+    kind: "createColumn";
+    table: string;
+    column: ColumnMeta;
+}
+export interface UpdateColumnChange {
+    kind: "updateColumn";
+    table: string;
+    before: ColumnMeta;
+    after: ColumnMeta;
+}
+export interface DeleteColumnChange {
+    kind: "deleteColumn";
+    table: string;
+    column: ColumnMeta;
+}
+export interface CreateConstraintChange {
+    kind: "createConstraint";
+    table: string;
+    constraint: ConstraintMeta;
+}
+export interface DeleteConstraintChange {
+    kind: "deleteConstraint";
+    table: string;
+    constraint: ConstraintMeta;
+}
+export interface CreateIndexChange {
+    kind: "createIndex";
+    table: string;
+    index: IndexDefinitionMeta;
+}
+export interface DeleteIndexChange {
+    kind: "deleteIndex";
+    table: string;
+    index: IndexDefinitionMeta;
+}
+export type MetaChange = CreateTableChange | DeleteTableChange | CreateColumnChange | UpdateColumnChange | DeleteColumnChange | CreateConstraintChange | DeleteConstraintChange | CreateIndexChange | DeleteIndexChange;
+interface ChangeFactory<T> {
+    create: (value: T) => MetaChange;
+    delete: (value: T) => MetaChange;
+    update?: (before: T, after: T) => MetaChange;
+}
+export interface MigrationContext {
+    changes: Array<MetaChange>;
+    current: DatabaseMeta;
+}
+export declare class Parameter {
+    readonly value: Primitive;
+    constructor(value: Primitive);
+}
+export declare class Sql<T = unknown> {
+    protected $chunks: Array<Chunk>;
+    constructor(...chunks: Array<Chunk>);
+    push(...chunks: Array<Chunk>): this;
+    toQuery(): Query<T>;
+    toSql(): this;
+}
+export declare abstract class Statement<T = unknown> extends Sql<T> {
+    protected $session: Session;
+    protected $fields: Array<[string, Column]>;
+    constructor(session: Session, value: Table | Record<string, Column>, ...chunks: Array<Chunk>);
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    protected mapRow(row: Array<unknown>): Record<string, unknown>;
+}
+export declare class SelectStatement<TSelection = Table | Record<string, Column>, TMode extends SelectMode = TSelection extends Table ? "single" : "partial", TNullability extends Record<string, boolean> = TSelection extends Table ? Record<TSelection["$name"], false> : {}> extends Statement<Array<SelectResult<TSelection, TMode, TNullability>>> {
+    protected $value: TSelection;
+    protected $selection: Sql;
+    protected $baseNullable: boolean;
+    protected $joins: {
+        table: Table;
+        nullable: boolean;
+    }[];
+    constructor(session: Session, value: TSelection);
+    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">>;
+    innerJoin<TTable extends Table>(table: TTable, on: Chunk): SelectStatement<AppendToSelection<TSelection, TTable, TMode>, TMode extends "partial" ? "partial" : "multiple", AppendToNullabilityMap<TNullability, TTable, "inner">>;
+    crossJoin<TTable extends Table>(table: TTable): SelectStatement<AppendToSelection<TSelection, TTable, TMode>, TMode extends "partial" ? "partial" : "multiple", AppendToNullabilityMap<TNullability, TTable, "cross">>;
+    where(chunk: Chunk): this & Record<"where", never>;
+    groupBy(...columns: Array<Chunk>): this & Record<"groupBy", never>;
+    having(chunk: Chunk): this & Record<"having", never>;
+    orderBy(...chunks: Array<Chunk>): this & Record<"orderBy", never>;
+    limit(count: number): this & Record<"limit", never>;
+    offset(count: number): this & Record<"offset", never>;
+    protected mapRow(row: Array<unknown>): Record<string, unknown>;
+}
+export declare class InsertStatement<T extends Table = Table> extends Statement<Array<InferSelectModel<T>>> {
+    protected $table: T;
+    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>;
+    returning<This extends InsertStatement>(this: This): This & Record<"returning", never>;
+}
+export declare class UpdateStatement<T extends Table = Table> extends Statement<Array<InferSelectModel<T>>> {
+    protected $table: T;
+    constructor(session: Session, table: T);
+    set<This extends UpdateStatement>(this: This, value: Partial<InferInsertModel<T>>): This & Record<"set", never>;
+    where<This extends UpdateStatement>(this: This, chunk: Chunk): This & Record<"where", never>;
+    returning<This extends UpdateStatement>(this: This): This & Record<"returning", never>;
+}
+export declare class DeleteStatement<T extends Table = Table> extends Statement<Array<InferSelectModel<T>>> {
+    protected $table: T;
+    constructor(session: Session, table: T);
+    where<This extends DeleteStatement>(this: This, chunk: Chunk): This & Record<"where", never>;
+    returning<This extends DeleteStatement>(this: This): This & Record<"returning", never>;
+}
+export declare abstract class PreparedQuery {
+    protected $query: Query;
+    constructor(query: Query);
+    getQuery(): Query<unknown>;
+    abstract run(parameters: Array<Primitive>): unknown;
+    abstract all(parameters: Array<Primitive>): unknown;
+    abstract get(parameters: Array<Primitive>): unknown;
+    abstract values(parameters: Array<Primitive>): unknown;
+}
+export declare abstract class Session {
+    run(query: Query): unknown;
+    all(query: Query): unknown;
+    get(query: Query): unknown;
+    values(query: Query): unknown;
+    abstract prepareQuery(query: Query): PreparedQuery;
+}
+export declare abstract class Migration {
+    abstract readonly $dialect: string;
+    toSql(changes: Array<MetaChange>, current: DatabaseMeta): Array<string>;
+    protected render({ changes }: MigrationContext): Array<string>;
+    diff(previous: DatabaseMeta | undefined, current: DatabaseMeta): MetaChange[];
+    protected diffValues<T>(before: Map<string, T>, after: Map<string, T>, factory: ChangeFactory<T>): MetaChange[];
+    protected splitDefinitions(definitions: Array<DefinitionMeta>): {
+        constraints: Map<string, ConstraintMeta>;
+        indexes: Map<string, IndexDefinitionMeta>;
+    };
+    protected definitionFingerprint(definition: DefinitionMeta): string;
+    protected renderChange(change: MetaChange): Array<string>;
+    protected toCreateTableChange(change: CreateTableChange, name?: string): Array<string>;
+    protected toDeleteTableChange(change: DeleteTableChange): Array<string>;
+    protected toCreateColumnChange(change: CreateColumnChange, inline?: boolean): Array<string>;
+    protected toUpdateColumnChange(change: UpdateColumnChange): Array<string>;
+    protected toDeleteColumnChange(change: DeleteColumnChange): Array<string>;
+    protected toCreateConstraintChange(change: CreateConstraintChange, inline?: boolean): Array<string>;
+    protected toDeleteConstraintChange(change: DeleteConstraintChange): Array<string>;
+    protected toCreateIndexChange(change: CreateIndexChange): Array<string>;
+    protected toDeleteIndexChange(change: DeleteIndexChange): Array<string>;
+    protected columnConstraints(column: ColumnMeta): ConstraintMeta[];
+    protected updateColumnConstraints(table: string, before: ColumnMeta, after: ColumnMeta): string[];
+    protected constraintName(table: string, constraint: ConstraintMeta): string;
+    protected indexName(table: string, index: IndexDefinitionMeta): string;
+    protected generatedName(parts: Array<string>): string;
+    protected hash(value: string): string;
+    protected quoteIdentifiers(values: Array<string>): string;
+    protected alterTable(table: string, value: string): string;
+    protected equals(left: unknown, right: unknown): boolean;
+    protected serializeLiteral(value: string | number | boolean | null): string;
+    protected abstract quoteIdentifier(value: string): string;
+}
+export declare abstract class Database<T extends Record<string, Table> = Record<string, Table>> {
+    readonly $schema: T;
+    readonly $session: Session;
+    abstract readonly $migration: Migration;
+    get $dialect(): string;
+    constructor(session: Session, schema: T);
+    toMeta(): DatabaseMeta;
+    abstract select<TValue extends Table | Record<string, Column>>(value: TValue): SelectStatement<TValue>;
+    abstract insert<TValue extends Table>(table: TValue): InsertStatement<TValue>;
+    abstract update<TValue extends Table>(table: TValue): UpdateStatement<TValue>;
+    abstract delete<TValue extends Table>(table: TValue): DeleteStatement<TValue>;
+}
+export declare abstract class Table<TName extends string = string, TColumns extends Record<string, Column> = Record<string, Column>> {
+    readonly $name: TName;
+    readonly $columns: TColumns;
+    readonly $definitions: Array<Definition>;
+    constructor(name: TName, columns: TColumns, definitions: Array<Definition>);
+    toMeta(): TableMeta;
+    toSql(): Sql<unknown>;
+}
+export declare abstract class Column<TDataType = unknown> {
+    $name: string;
+    $table: Table | undefined;
+    $notNull: boolean;
+    $primaryKey: boolean;
+    $unique: boolean;
+    $defaultValue: DefaultValue<TDataType>;
+    $references: References;
+    $onDelete: ReferentialAction | undefined;
+    $onUpdate: ReferentialAction | undefined;
+    constructor(name: string);
+    default<This extends Column>(this: This, defaultValue: DefaultValue<Data<This>>): This & Record<"default", never>;
+    notNull<This extends Column>(this: This): This & Record<"notNull", never>;
+    unique<This extends Column>(this: This): This & Record<"unique", never>;
+    primaryKey<This extends Column>(this: This): This & Record<"primaryKey", never>;
+    references<This extends Column>(this: This, references: References, actions?: ReferentialActions): This & Record<"references", never>;
+    fromDriverValue(value: unknown): TDataType;
+    toDriverValue(value: TDataType): Primitive;
+    toSql(): Sql<unknown>;
+    toSqlName(): Sql<unknown>;
+    toMeta(): ColumnMeta;
+    abstract toSqlType(): string;
+}
+export declare class UniqueConstraint {
+    $columns: Array<Column>;
+    constructor(...columns: Array<Column>);
+    on<This extends UniqueConstraint>(this: This, ...columns: Array<Column>): This & Record<"on", never>;
+    toMeta(): UniqueConstraintMeta;
+}
+export declare class CheckConstraint {
+    $value: Sql;
+    protected $query: Query;
+    constructor(value: Sql);
+    toMeta(): CheckConstraintMeta;
+}
+export declare class PrimaryKeyConstraint {
+    $columns: Array<Column>;
+    constructor(...columns: Array<Column>);
+    toMeta(): PrimaryKeyConstraintMeta;
+}
+export declare class ForeignKeyConstraint {
+    $columns: Array<Column>;
+    $foreignColumns: Array<Column>;
+    constructor(columns: Array<Column>, foreignColumns: Array<Column>);
+    toMeta(): ForeignKeyConstraintMeta;
+}
+export declare class Index {
+    $columns: Array<Column>;
+    constructor(...columns: Array<Column>);
+    on<This extends Index>(this: This, ...columns: Array<Column>): This & Record<"on", never>;
+    toMeta(): IndexMeta;
+}
+export declare class UniqueIndex {
+    $columns: Array<Column>;
+    constructor(...columns: Array<Column>);
+    on<This extends UniqueIndex>(this: This, ...columns: Array<Column>): This & Record<"on", never>;
+    toMeta(): UniqueIndexMeta;
+}
+export declare function toParameter(column: Column, value: unknown): Chunk;
+export declare function combine<T>(chunks: Array<Chunk>, separator: string): Sql<T>;
+export declare function sql<T>(tokens: TemplateStringsArray, ...values: Array<Chunk>): Sql<T>;
+export declare function equals<T>(column: Column, right: Chunk): Sql<T>;
+export declare function greater<T>(column: Column, right: Chunk): Sql<T>;
+export declare function greaterEquals<T>(column: Column, right: Chunk): Sql<T>;
+export declare function lower<T>(column: Column, right: Chunk): Sql<T>;
+export declare function lowerEquals<T>(column: Column, right: Chunk): Sql<T>;
+export declare function like<T>(column: Column, right: Chunk): Sql<T>;
+export declare function contains<T>(column: Column, values: Array<Chunk>): Sql<T>;
+export declare function nullish<T>(chunk: Chunk): Sql<T>;
+export declare function not<T>(chunk: Chunk): Sql<T>;
+export declare function exists<T>(chunk: Chunk): Sql<T>;
+export declare function between<T>(column: Column, from: Chunk, to: Chunk): Sql<T>;
+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 useStorage<TSource extends Source<(scope: Scope) => Database> = typeof import("#storage").default, TScope extends SourceScope<TSource> = SourceScope<TSource>>(scope: Scope, scopeName: TScope): { [TKey in SourceValue<TSource, TScope>]: ReturnType<Awaited<ReturnType<TSource[TScope][TKey]>>>; };
+export declare const STORAGE_CONTEXT: import("revojs").Descriptor<Record<string, Record<string, Database<Record<string, Table<string, Record<string, Column<unknown>>>>>>>>;
+export {};