@foul11/awesome-db 1.1.0

package/src/WebpackFileProvider.ts

@@ -0,0 +1,63 @@
+import type { Migration, MigrationProvider } from 'kysely/migration';
+import type { requireDContext } from '@foul11/awesome';
+
+type RequireContext = Awaited<ReturnType<typeof requireDContext>>;
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+function isFunction(obj: unknown): obj is Function {
+    return typeof obj === 'function';
+}
+
+function isObject(obj: unknown): obj is Record<string, unknown> {
+    return typeof obj === 'object' && obj !== null;
+}
+
+function isMigration(obj: unknown): obj is Migration {
+    return isObject(obj) && isFunction(obj.up);
+}
+
+export class WebpackFileProvider implements MigrationProvider {
+    static db_migrations = new Map<string, Record<string, any>>();
+    
+    #db_name: string;
+    
+    constructor(db_name: string) {
+        this.#db_name = db_name;
+    }
+    
+    getMigrations(): Promise<Record<string, Migration>> {
+        const migrations_list: Record<string, Migration> = {};
+        const migrations = WebpackFileProvider.db_migrations.get(this.#db_name);
+        
+        if (!migrations)
+            return Promise.resolve(migrations_list);
+        
+        for (const [ file, exports ] of Object.entries(migrations)) {
+            if (isMigration(exports?.default)) {
+                migrations_list[file] = exports.default;
+            } else if (isMigration(exports)) {
+                migrations_list[file] = exports;
+            }
+        }
+        
+        return Promise.resolve(migrations_list);
+    }
+    
+    static setupDynamicImport(ctx: RequireContext, db_name?: string) {
+        for (const [ fpath, exports ] of ctx.keys().map(m => [ m, ctx(m) ])) {
+            const [ , db, file ] = /^.+[\\/]([^\\/]+)[\\/](.+)\.[jt]s$/i.exec(fpath) ?? [];
+            
+            if (!db_name)
+                db_name = db;
+            
+            if (!db_name || !file)
+                continue;
+            
+            if (WebpackFileProvider.db_migrations.has(db_name)) {
+                WebpackFileProvider.db_migrations.get(db_name)!  [file] = exports;
+            } else {
+                WebpackFileProvider.db_migrations.set(db_name, { [file]: exports });
+            }
+        }
+    }
+}

package/src/alter/column_add.ts

@@ -0,0 +1,79 @@
+import { itAddColumn, tmpTableName } from './utils';
+import { get_table_schema } from '../utils';
+import { pragma_foreign_keys } from './pragma';
+
+
+import type { Kysely, AnyColumn, ColumnDefinitionBuilder, ExpressionBuilder, AliasedExpression, Expression } from 'kysely';
+import type { ExtractTableAlias } from './utils';
+
+/**
+ * Alter column add after column, or first if null
+ */
+export async function alter_column_add<DB, TB extends Extract<keyof DB, string>, CN extends AnyColumn<DB, TB>>(
+    db: Kysely<DB>,
+    table: TB,
+    column_name: CN,
+    column_type: Expression<unknown>,
+    after: CN | null,
+    col: (col: ColumnDefinitionBuilder) => ColumnDefinitionBuilder,
+    eb?: ((eb: ExpressionBuilder<DB, ExtractTableAlias<DB, TB>>) => AliasedExpression<any, CN>),
+) {
+    await pragma_foreign_keys(db, false);
+    await db
+        .transaction()
+        .execute(async (trx) => {
+            const alter_table = tmpTableName(table);
+            const schema = await get_table_schema(trx, table);
+            
+            if (!schema)
+                throw new Error(`Table ${table} does not exist`);
+            
+            if (schema.columns.some(c => c.name == column_name))
+                return; // passthrough if column already exists
+            
+            const after_column_idx = schema.columns.findIndex(c => c.name == after);
+            
+            let columns_after  = [] as any[];
+            let columns_before = [] as any[];
+            
+            if (after_column_idx !== -1) {
+                columns_after  = schema.columns.slice(0, after_column_idx + 1);
+                columns_before = schema.columns.slice(after_column_idx + 1);
+            } else {
+                columns_after = [];
+                columns_before = schema.columns;
+            }
+            
+            let builder = trx.schema.createTable(alter_table);
+                builder = itAddColumn(builder, columns_after);
+                builder = builder.addColumn(column_name, column_type, col);
+                builder = itAddColumn(builder, columns_before);
+            await builder.execute();
+            
+            await trx
+                .insertInto(alter_table)
+                .columns([
+                    ...columns_after.map(c => c.name),
+                    ...(eb ? [ column_name ] : []),
+                    ...columns_before.map(c => c.name),
+                ])
+                .expression(() => (trx as any)
+                    .selectFrom(table)
+                    .select([
+                        ...columns_after.map(c => `${table}.${c.name}`),
+                        ...(eb ? [ eb ] : []),
+                        ...columns_before.map(c => `${table}.${c.name}`),
+                    ]))
+                .executeTakeFirstOrThrow();
+                
+            await trx.schema
+                .dropTable(table)
+                .execute();
+                
+            await trx.schema
+                .alterTable(alter_table)
+                .renameTo(table)
+                .execute();
+        });
+    await pragma_foreign_keys(db, true);
+}

package/src/alter/column_drop.ts

@@ -0,0 +1,54 @@
+import { itAddColumn, tmpTableName } from './utils';
+import { get_table_schema } from '../utils';
+import { pragma_foreign_keys } from './pragma';
+
+
+import type { Kysely } from 'kysely';
+
+
+/**
+ * Alter column drop
+ */
+export async function alter_column_drop<DB, TB extends Extract<keyof DB, string>>(
+    db: Kysely<DB>,
+    table: TB,
+    column_name: string,
+) {
+    await pragma_foreign_keys(db, false);
+    await db
+        .transaction()
+        .execute(async (trx) => {
+            const alter_table = tmpTableName(table);
+            const schema = await get_table_schema(trx, table);
+            
+            if (!schema)
+                throw new Error(`Table ${table} does not exist`);
+            
+            if (!schema.columns.find(c => c.name == column_name)?.type)
+                return; // passthrough if column not found
+            
+            const columns = schema.columns.filter(c => c.name != column_name);
+            
+            let builder = trx.schema.createTable(alter_table);
+                builder = itAddColumn(builder, columns);
+            await builder.execute();
+            
+            await trx
+                .insertInto(alter_table)
+                .columns(columns.map(c => c.name) as any)
+                .expression(eb => (eb as any)
+                    .selectFrom(table)
+                    .select(columns.map(c => `${table}.${c.name}`)))
+                .executeTakeFirstOrThrow();
+                
+            await trx.schema
+                .dropTable(table)
+                .execute();
+                
+            await trx.schema
+                .alterTable(alter_table)
+                .renameTo(table)
+                .execute();
+        });
+    await pragma_foreign_keys(db, true);
+}

package/src/alter/column_rename.ts

@@ -0,0 +1,55 @@
+import { itAddColumn, tmpTableName } from './utils';
+import { get_table_schema } from '../utils';
+import { pragma_foreign_keys } from './pragma';
+
+
+import type { Kysely, AnyColumn } from 'kysely';
+
+
+/**
+ * Alter column rename
+ */
+export async function alter_column_rename<DB, TB extends Extract<keyof DB, string>>(
+    db: Kysely<DB>,
+    table: TB,
+    column_name: string,
+    new_column_name: AnyColumn<DB, TB>,
+) {
+    await pragma_foreign_keys(db, false);
+    await db
+        .transaction()
+        .execute(async (trx) => {
+            const alter_table = tmpTableName(table);
+            const schema = await get_table_schema(trx, table);
+            
+            if (!schema)
+                throw new Error(`Table ${table} does not exist`);
+            
+            const columns = schema.columns;
+            
+            if (columns.some(c => c.name === new_column_name))
+                return; // passthrough if column already exists
+            
+            let builder = trx.schema.createTable(alter_table);
+                builder = itAddColumn(builder, columns.map(c => ({ ...c, name: c.name == column_name ? new_column_name : c.name })));
+            await builder.execute();
+            
+            await trx
+                .insertInto(alter_table)
+                .columns(columns.map(c => c.name == column_name ? new_column_name : c.name) as any)
+                .expression(eb => (eb as any)
+                    .selectFrom(table)
+                    .select(columns.map(c => `${table}.${c.name}`)))
+                .executeTakeFirstOrThrow();
+                
+            await trx.schema
+                .dropTable(table)
+                .execute();
+                
+            await trx.schema
+                .alterTable(alter_table)
+                .renameTo(table)
+                .execute();
+        });
+    await pragma_foreign_keys(db, true);
+}

package/src/alter/column_update.ts

@@ -0,0 +1,92 @@
+import { itAddColumn, tmpTableName } from './utils';
+import { SQLParser } from '../SQLParser';
+import { get_table_schema } from '../utils';
+import { pragma_foreign_keys } from './pragma';
+
+import type { Kysely, AnyColumn, ColumnDefinitionBuilder, ExpressionBuilder, AliasedExpression, Expression } from 'kysely';
+import type { ExtractTableAlias } from './utils';
+
+/**
+ * Alter column update settings (e.g. not null)
+ */
+export async function alter_column_update<
+    DB,
+    TB extends Extract<keyof DB, string>,
+    CN extends AnyColumn<DB, TB>,
+>(
+    db: Kysely<DB>,
+    table: TB,
+    column_name: CN,
+    column_type: Expression<unknown>,
+    col: (col: ColumnDefinitionBuilder) => ColumnDefinitionBuilder,
+    eb: ((eb: ExpressionBuilder<DB, ExtractTableAlias<DB, TB>>) => AliasedExpression<any, CN>) | null = null,
+) {
+    await pragma_foreign_keys(db, false);
+    await db
+        .transaction()
+        .execute(async (trx) => {
+            const alter_table = tmpTableName(table);
+            const schema = await get_table_schema(trx, table);
+            
+            if (!schema)
+                throw new Error(`Table ${table} does not exist`);
+            
+            let columns_after: typeof schema.columns | null  = null;
+            let columns_before: typeof schema.columns | null = null;
+            
+            const prev_column_idx = schema.columns.findIndex(c => c.name == column_name);
+            
+            if (prev_column_idx === -1)
+                throw new Error(`Column ${column_name} does not exist`);
+            
+            columns_after  = schema.columns.slice(0, prev_column_idx);
+            columns_before = schema.columns.slice(prev_column_idx + 1);
+            
+            let builder = trx.schema.createTable(alter_table);
+                builder = itAddColumn(builder, columns_after);
+                builder = builder.addColumn(column_name, column_type, col);
+                builder = itAddColumn(builder, columns_before);
+                
+            const create_schema = SQLParser.parse(builder.compile().sql)[0];
+            
+            if (create_schema?.type != 'CREATE_TABLE')
+                throw new Error('Invalid builded SQL');
+            
+            const old_column = schema.columns.find(c => c.name == column_name);
+            const new_column = create_schema.columns.find(c => c.name == column_name);
+            
+            if (!old_column || !new_column)
+                throw new Error('new/old column not found');
+            
+            if (JSON.stringify(old_column) == JSON.stringify(new_column))
+                return; // passthrough if column settings are the same
+                
+            await builder.execute();
+            
+            await trx
+                .insertInto(alter_table)
+                .columns([
+                    ...columns_after.map(c => c.name),
+                    column_name,
+                    ...columns_before.map(c => c.name),
+                ] as any)
+                .expression(() => (trx as any)
+                    .selectFrom(table)
+                    .select([
+                        ...columns_after.map(c => `${table}.${c.name}`),
+                        ...(eb ? [ eb ] : [ `${table}.${column_name}` ]),
+                        ...columns_before.map(c => `${table}.${c.name}`),
+                    ]))
+                .executeTakeFirstOrThrow();
+                
+            await trx.schema
+                .dropTable(table)
+                .execute();
+                
+            await trx.schema
+                .alterTable(alter_table)
+                .renameTo(table)
+                .execute();
+        });
+    await pragma_foreign_keys(db, true);
+}

package/src/alter/columns_order.ts

@@ -0,0 +1,60 @@
+import { itAddColumn, tmpTableName } from './utils';
+import { get_table_schema } from '../utils';
+import { pragma_foreign_keys } from './pragma';
+
+
+import type { Kysely, AnyColumn } from 'kysely';
+
+
+/**
+ * Alter column order
+ */
+export async function alter_column_order<DB, TB extends Extract<keyof DB, string>>(
+    db: Kysely<DB>,
+    table: TB,
+    columns_name: AnyColumn<DB, TB>[],
+) {
+    await pragma_foreign_keys(db, false);
+    await db
+        .transaction()
+        .execute(async (trx) => {
+            const alter_table = tmpTableName(table);
+            const schema = await get_table_schema(trx, table);
+            
+            if (!schema)
+                throw new Error(`Table ${table} does not exist`);
+            
+            const schema_columns = new Map(schema.columns.map((c, i) => [ c.name,   i ]));
+            const new_columns    = new Map(columns_name  .map((c, i) => [ c as any, i ]));
+            
+            if (schema_columns.size != new_columns.size || schema_columns.size != columns_name.length)
+                throw new Error(`Table ${table} column count mismatch`);
+            
+            if (![ ...schema_columns.entries() ].some(([ c_name, idx ]) => new_columns.get(c_name) != idx))
+                return; // passthrough if column order is the same
+            
+            let builder = trx.schema.createTable(alter_table);
+                builder = itAddColumn(builder, columns_name.map(c =>
+                    schema.columns[schema_columns.get(c)!],
+                ));
+            await builder.execute();
+            
+            await trx
+                .insertInto(alter_table)
+                .columns(columns_name)
+                .expression(eb => (eb as any)
+                    .selectFrom(table)
+                    .select(columns_name.map(c => `${table}.${c}`)))
+                .executeTakeFirstOrThrow();
+                
+            await trx.schema
+                .dropTable(table)
+                .execute();
+                
+            await trx.schema
+                .alterTable(alter_table)
+                .renameTo(table)
+                .execute();
+        });
+    await pragma_foreign_keys(db, true);
+}

package/src/alter/index.ts

@@ -0,0 +1,6 @@
+export * from './column_add';
+export * from './column_drop';
+export * from './column_rename';
+export * from './column_update';
+export * from './columns_order';
+export * from './pragma';

package/src/alter/pragma.ts

@@ -0,0 +1,10 @@
+import { sql } from 'kysely';
+import type { Kysely } from 'kysely';
+
+export async function pragma_foreign_keys(db: Kysely<any>, enable: boolean) {
+    return sql`PRAGMA foreign_keys = ${sql.lit(enable ? 1 : 0)}`.execute(db);
+}
+
+export async function pragma_defer_foreign_keys(db: Kysely<any>, enable: boolean) {
+    return sql`PRAGMA defer_foreign_keys = ${sql.lit(enable ? 1 : 0)}`.execute(db);
+}

package/src/alter/utils.ts

@@ -0,0 +1,70 @@
+import { sql } from 'kysely';
+
+import type { SQLParser } from '../SQLParser';
+import type { ColumnDefinitionBuilder, CreateTableBuilder } from 'kysely';
+
+export type ExtractTableAlias<DB, TE> = TE extends `${string} as ${infer TA}`
+    ? TA extends keyof DB
+        ? TA
+        : never
+    : TE extends keyof DB
+        ? TE
+        : never;
+
+function columnDefinition(col: ColumnDefinitionBuilder, columnDef: ReturnType<typeof SQLParser['sqliteColumnsDef']>[0]) {
+    if (columnDef.primary)
+        col = col.primaryKey();
+    
+    if (columnDef.unique)
+        col = col.unique();
+    
+    if (columnDef.auto_increment)
+        col = col.autoIncrement();
+    
+    if (columnDef.not_null)
+        col = col.notNull();
+    
+    if (columnDef.default !== null) {
+        if (typeof columnDef.default == 'string' && columnDef.default[0] == '(') {
+            col = col.defaultTo(sql.raw(columnDef.default));
+        } else {
+            col = col.defaultTo(sql.lit(columnDef.default));
+        }
+    }
+    
+    if (columnDef.references) {
+        if (!columnDef.references.columns.length || columnDef.references.columns.length > 1)
+            throw new Error('Only one column can be referenced');
+        
+        const column_name = columnDef.references.columns[0];
+        const schema_name = [
+            ...columnDef.references.table.scheme_parts,
+            columnDef.references.table.name,
+            column_name,
+        ].join('.');
+        
+        col = col.references(schema_name);
+        
+        if (columnDef.references.constraints) {
+            col = col.modifyEnd(sql.raw(` ${columnDef.references.constraints}`));
+        }
+    }
+    
+    return col;
+}
+
+export function itAddColumn<TABLE_NAME extends string>(builder: CreateTableBuilder<TABLE_NAME, never>, columns: ReturnType<typeof SQLParser['sqliteColumnsDef']>) {
+    for (const column of columns) {
+        builder = builder.addColumn(
+            column.name,
+            column.type.toLowerCase() as Lowercase<typeof column.type>,
+            col => columnDefinition(col, column),
+        );
+    }
+    
+    return builder;
+}
+
+export function tmpTableName(table: string) {
+    return `alter_${Math.floor(Date.now() / 1000)}_${table}` as any;
+}

package/src/defaults.ts

@@ -0,0 +1,3 @@
+import { sql } from 'kysely';
+
+export const currTimeDefault = sql`(strftime('%FT%R:%fZ'))`;