@smuzi/database 0.0.2 → 0.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smuzi/database",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Database access layer and migrations toolkit for JavaScript and TypeScript",
   "type": "module",
   "types": "./build/index.d.ts",
@@ -15,8 +15,8 @@
     "access": "public"
   },
   "files": [
-    "./src",
-    "./build"
+    "build/**/*.js",
+    "build/**/*.d.ts"
   ],
   "exports": {
     "./package.json": "./package.json",
@@ -33,9 +33,9 @@
     "#lib/*": "./src/*"
   },
   "dependencies": {
-    "@smuzi/std": "0.2.6",
-    "@smuzi/schema": "0.0.4",
-    "@smuzi/console": "0.0.3"
+    "@smuzi/std": "0.2.8",
+    "@smuzi/schema": "0.0.7",
+    "@smuzi/console": "0.0.6"
   },
   "devDependencies": {
     "@types/node": "^22.15.21",
@@ -43,5 +43,6 @@
   },
   "scripts": {
     "build": "tsc --project tsconfig.build.json"
-  }
+  },
+  "main": "./build/index.js"
 }

package/src/commands/migrations/fresh.ts

@@ -1,15 +0,0 @@
-import {TDatabaseService} from "../../types.js";
-import {TOutputConsole} from "@smuzi/console";
-import run from "./run.js";
-import {Ok, OkOrNullableAsError, OptionFromNullable} from "@smuzi/std";
-
-export default function (service: TDatabaseService) {
-    return async (output: TOutputConsole, params) => {
-
-        output.success('Drop all tables...');
-
-        (await service.buildMigrationLogRepository(service.client).freshSchema()).unwrap()
-
-        await run(service)(output, params);
-    }
-}

package/src/commands/migrations/refresh.ts

@@ -1,57 +0,0 @@
-import {TDatabaseService } from "../../types.js";
-import {TOutputConsole} from "@smuzi/console";
-import {Ok, OkOrNullableAsError, OptionFromNullable} from "@smuzi/std";
-import {clearSQL} from "../../helpers.js";
-import {TMigrationLogAction} from "../../migration.js";
-
-export default function (service: TDatabaseService) {
-    return async (output: TOutputConsole, params) => {
-        const migrationsLogRepository = service.buildMigrationLogRepository(service.client);
-
-        const sortedLogMigrations = (await migrationsLogRepository.listRuned()).unwrap();
-        const migrations = service.buildMigrations();
-
-        if (sortedLogMigrations.rowCount.isZero()) {
-            return;
-        }
-
-        for (const [key, rowLog] of sortedLogMigrations.rows) {
-            const name = rowLog.get("name").unwrap();
-            const migration = migrations.getByName(name)
-
-            output.success('Down migration - ' + name)
-
-            const sql_source = clearSQL(migration.down());
-            (await service.client.query(sql_source)).unwrap();
-
-            (await migrationsLogRepository.create({
-                name,
-                branch: rowLog.get("branch").unwrap(),
-                action: TMigrationLogAction.down,
-                sql_source,
-                created_at: new Date()
-            })).unwrap()
-        }
-
-        const branch = (await migrationsLogRepository.getLastBranch())
-            .match({
-                Some: value => ++value,
-                None: () => 1
-            })
-
-        for (const [name, migration] of migrations.getList()) {
-            output.success('Run migration - ' + name)
-
-            const sql_source = clearSQL(migration.up());
-            await service.client.query(sql_source);
-
-            await migrationsLogRepository.create({
-                name,
-                branch,
-                action: TMigrationLogAction.up,
-                sql_source,
-                created_at: new Date()
-            })
-        }
-    }
-}

package/src/commands/migrations/rollback.ts

@@ -1,45 +0,0 @@
-import {TDatabaseService} from "../../types.js";
-import {Ok, OkOrNullableAsError, OptionFromNullable} from "@smuzi/std";
-import {TOutputConsole} from "@smuzi/console";
-import {clearSQL} from "../../helpers.js";
-import {TMigrationLogAction} from "../../migration.js";
-
-export default function (service: TDatabaseService) {
-    return async (output: TOutputConsole, params) => {
-
-        const migrationsLogRepository = service.buildMigrationLogRepository(service.client);
-
-        const branch = await params.get("branch").match({
-            Some: async (val) => val as number,
-            None: async () => (await migrationsLogRepository.getLastBranch()).unwrap(`Last branch not founded in ${migrationsLogRepository.getTable()} table`)
-        });
-
-        output.info("Branch for rollback - " + branch)
-
-        const logMigrations = (await migrationsLogRepository.listRunedByBranch(branch)).unwrap();
-        const migrations = service.buildMigrations();
-
-       if (logMigrations.rowCount.isZero()) {
-            return;
-        }
-        
-        for (const [key, rowLog] of logMigrations.rows) {
-            const name = rowLog.get("name").unwrap();
-
-            const migration = migrations.getByName(name)
-
-            output.success('Down migration - ' + name)
-
-            const sql_source = clearSQL(migration.down());
-            (await service.client.query(sql_source)).unwrap();
-
-            (await migrationsLogRepository.create({
-                name,
-                branch,
-                action: TMigrationLogAction.down,
-                sql_source,
-                created_at: new Date(),
-            })).unwrap()
-        }
-    }
-}

package/src/commands/migrations/run.ts

@@ -1,40 +0,0 @@
-import {TDatabaseService} from "../../types.js";
-import {Ok, OkOrNullableAsError, OptionFromNullable} from "@smuzi/std";
-import {TOutputConsole} from "@smuzi/console";
-import {clearSQL} from "../../helpers.js";
-import {TMigrationLogAction} from "../../migration.js";
-
-export default function (service: TDatabaseService) {
-    return async (output: TOutputConsole, params) => {
-
-        const migrationsLogRepository = service.buildMigrationLogRepository(service.client);
-
-        (await migrationsLogRepository.createTableIfNotExists()).unwrap();
-
-        const branch = (await migrationsLogRepository.getLastBranch())
-            .match({
-                Some: value => ++value,
-                None: () => 1
-            })
-
-        for (const [name, migration] of service.buildMigrations().getList()) {
-            if (await migrationsLogRepository.migrationWillBeRuned(name)) {
-                continue;
-            }
-
-            output.success('Run migration - ' + name)
-
-            const sql_source = clearSQL(migration.up());
-
-            (await service.client.query(sql_source)).unwrap();
-
-           (await migrationsLogRepository.create({
-                name,
-                branch,
-                action: TMigrationLogAction.up,
-                sql_source,
-                created_at: new Date(),
-            })).unwrap();
-        }
-    }
-}

package/src/commands/router.ts

@@ -1,21 +0,0 @@
-import {CreateConsoleRouter} from "@smuzi/console";
-import migrationsRun from "./migrations/run.js";
-import migrationsRollback from "./migrations/rollback.js";
-import migrationsRefresh from "./migrations/refresh.js";
-import migrationsFresh from "./migrations/fresh.js";
-
-
-export const databaseConsole = (config) => {
-    const router = CreateConsoleRouter('db:');
-    const routerMigrations = CreateConsoleRouter('migrations:');
-
-    routerMigrations.add('run', migrationsRun(config))
-    routerMigrations.add('rollback', migrationsRollback(config))
-    routerMigrations.add('refresh', migrationsRefresh(config))
-    routerMigrations.add('fresh', migrationsFresh(config))
-
-    router.group(routerMigrations);
-
-    return router;
-}
-

package/src/config.ts

@@ -1,6 +0,0 @@
-import {TDatabaseService} from "./types.js";
-import {readonly} from "@smuzi/std";
-
-export function DatabaseConfig(config: TDatabaseService) {
-    return readonly(config);
-}

package/src/helpers.ts

@@ -1,30 +0,0 @@
-import {dump, Err, isEmpty, isOption, Ok, Result} from "@smuzi/std";
-import {TQueryParams} from "./types.js";
-
-export function clearSQL(sql: string): string
-{
-    return sql.trim();
-}
-
-export function preparedSqlFromObjectToArrayParams(sql: string, params: TQueryParams): Result<{sql: string, params: any[]}, string>
-{
-    let paramArray: string[] = [];
-    let index = 1;
-    let error = '';
-
-    const processedSql = sql.replace(/:(\w+)/g, (input, key) => {
-        if (params.hasOwnProperty(key)) {
-            paramArray.push(isOption(params[key]) ? params[key].someOr(null) : params[key]);
-            return `$${index++}`;
-        }
-        error += `Missing parameter: ${key}. `;
-
-        return input;
-    });
-
-    if (isEmpty(error)) {
-        return Ok({sql: processedSql, params: paramArray});
-    }
-
-    return Err(error);
-}

package/src/index.ts

@@ -1,5 +0,0 @@
-export * from "./migration.js"
-export * from "./commands/router.js"
-export * from "./config.js"
-export * from "./types.js"
-export * from "./helpers.js"

package/src/migration.ts

@@ -1,80 +0,0 @@
-import {TInsertRow, TInsertRowResult, TQueryResult,} from "./types.js";
-import {Option, panic} from "@smuzi/std";
-import {schema, SchemaObject} from "@smuzi/schema";
-
-
-export const migrationLogRowSchema = schema.obj({
-    name: schema.string(),
-    branch: schema.number(),
-    action: schema.string(),
-    sql_source: schema.string(),
-    created_at: schema.datetime.native(),
-})
-
-export type TMigrationLogRowSchema = typeof migrationLogRowSchema;
-export type TMigrationLogSave = TMigrationLogRowSchema["__infer"]
-
-export type TMigration = {
-    up: () => string,
-    down: () => string,
-}
-
-export type TMigrations = {
-    add: (name: string, migration: TMigration) => void,
-    group: (migrations: TMigrations) => void,
-    getList: () => Map<string, TMigration>,
-    getByName: (name: string) => TMigration,
-    getGroupName:() => string
-}
-
-export enum TMigrationLogAction {
-    up = 'up',
-    down = 'down',
-}
-
-
-export type TMigrationsLogRepository = {
-    getTable(): string,
-    createTableIfNotExists(): Promise<TQueryResult<never>>,
-    listRuned(): Promise<TQueryResult<TMigrationLogRowSchema>>,
-    listRunedByBranch(branch: number): Promise<TQueryResult<TMigrationLogRowSchema>>,
-    getLastBranch(): Promise<Option<number>>,
-    create<const RC extends (keyof TMigrationLogSave)[]>(row: TInsertRow<TMigrationLogRowSchema>, returningColumns?: RC): Promise<TInsertRowResult<TMigrationLogRowSchema, RC>>,
-    migrationLastAction(name: string): Promise<Option<string>>,
-    migrationWillBeRuned(name: string): Promise<boolean>,
-    freshSchema(): Promise<TQueryResult<SchemaObject<any>>>
-};
-
-
-export const Migrations = (groupName: string = ''): TMigrations => {
-    const migrations = new Map();
-
-    return {
-        add(name: string, migration) {
-            if (migrations.has(name)) {
-                panic(`Migration with name = '${name}' is not unique`)
-            }
-            migrations.set(name, migration)
-        },
-        group(migrationsGroup) {
-            const groupName = migrationsGroup.getGroupName();
-
-            for (const [name, migration] of migrationsGroup.getList()) {
-                migrations.set(groupName + name, migration)
-            }
-        },
-        getList() {
-            return migrations;
-        },
-        getGroupName() {
-            return groupName;
-        },
-        getByName(name) {
-            return migrations.get(name);
-        }
-    }
-}
-
-export function Migration(migration: TMigration){
-    return migration;
-}

package/src/types.ts

@@ -1,189 +0,0 @@
-import {
-    dump,
-    None,
-    Option,
-    OptionFromNullable,
-    RecordFromKeys,
-    Result,
-    Simplify,
-    Some, StdError,
-    StdList,
-    StdRecord
-} from "@smuzi/std"
-import {
-    schema,
-    SchemaObject,
-    SchemaOption,
-    SchemaRule,
-    SchemaStorageAutoNumber,
-} from "@smuzi/schema"
-import {TMigrations, TMigrationsLogRepository} from "./migration.js";
-
-export type TQueryParams = unknown[] | Record<string, unknown>
-
-export class DBQueryError {
-    readonly sql: string
-    readonly message: string
-    readonly code: Option<string>
-    readonly detail: Option<string>
-    readonly table: Option<string>
-    readonly trace: string
-
-    constructor(config: {sql: string, message: string, code: Option<string>, detail: Option<string>, table: Option<string>} ) {
-        this.sql = config.sql;
-        this.message = config.message;
-        this.code = config.code;
-        this.detail = config.detail;
-        this.table = config.table;
-        this.trace = new Error().stack as string;
-    }
-
-    toError(): StdError {
-        return new StdError(
-            this.message,
-            Some(this.trace),
-            Some({
-                sql: this.sql,
-                code: this.code,
-                table: this.table,
-                detail: this.detail,
-            })
-        )
-    }
-}
-
-export type TQueryRawResult<S extends SchemaObject> = {
-    rows: TableRows<S>,
-    rowCount: Option<number>
-}
-export type TQueryResult<S extends SchemaObject> = Result<TQueryRawResult<S>, DBQueryError>
-export type TInsertRowResult<S extends SchemaObject, Columns extends readonly (keyof S["__infer"])[]> = Result<Option<Simplify<RecordFromKeys<S["__infer"], Columns>>>, DBQueryError>
-export type TInsertManyRowResult<S extends SchemaObject, Columns extends readonly (keyof S["__infer"])[], Prepared extends SchemaObject = SchemaObject<RecordFromKeys<ReturnType<S["getConfig"]>, Columns>>> = Result<TableRows<Prepared>, DBQueryError>
-
-
-export class TableRows<
-    Schema extends SchemaObject,
-    TableRow extends Option<Schema> extends Option<never> ? StdRecord<Record<string, unknown>> : StdRecord<Schema["__infer"]> = Option<Schema> extends Option<never> ? StdRecord<Record<string, unknown>> : StdRecord<Schema["__infer"]>,
-   Rows extends Array<Record<string, unknown>> = Array<Record<string, unknown>>
-> {
-    #rows: Rows
-    #schema: Option<Schema>
-
-    constructor(schema: Option<Schema>, rows: Rows) {
-        this.#rows = rows;
-        this.#schema = schema;
-    }
-
-    #prepareRow(row: Record<string, unknown>): TableRow {
-        return this.#schema.match({
-            None: () => new StdRecord(row) as TableRow,
-            Some: (schema) => {
-
-                const config = schema.getConfig();
-                const prepare = {} as any;
-                for (const field in config) {
-                    /**
-                     * TODO:
-                     * A database is a sufficiently reliable data source
-                     * to skip validating the retrieved data.
-                     * However, it is important to understand that type inference in this case
-                     * does not guarantee a 100% match with the actual database types.
-                     * This especially affects working with nullable fields.
-                     * For example, a field was required but later became nullable.
-                     * In this case, without changing the schema, `null` values will start flowing into your code.
-                     * This issue can be solved by `StdRecord`, but then all fields have to be handled as `Option`,
-                     * which is very inconvenient for developers.
-                    **/
-                    if (field in row) {
-                        if (config[field] instanceof SchemaOption) {
-                            prepare[field] = OptionFromNullable(row[field]);
-                        } else {
-                            prepare[field] = row[field];
-                        }
-                    }
-                }
-
-                return new StdRecord(prepare) as TableRow;
-            }
-        })
-
-    }
-
-    get(key: number): Option<TableRow> {
-        if (this.has(key)) {
-            return Some(this.#prepareRow(this.#rows[key]));
-        }
-
-        return None();
-    }
-
-    has(key: number) {
-        return key in this.#rows;
-    }
-
-    *entries(): IterableIterator<[number, TableRow]> {
-        for (let k = 0; k < this.#rows.length; k++) {
-            yield [k, this.get(k).unwrap()];
-        }
-    }
-
-    [Symbol.iterator](): IterableIterator<[number, TableRow]> {
-        return this.entries();
-    }
-
-    unsafeSource() {
-        return this.#rows;
-    }
-}
-
-
-export interface TDatabaseClient {
-    query<S extends SchemaObject<any>>(
-        sql: string,
-        params?: TQueryParams,
-        schema?: Option<S>
-    ): Promise<TQueryResult<S>>;
-  
-    insertRow<S extends SchemaObject<any>, const RC extends string[]>(
-        table: string,
-        schema: S,
-        row: TInsertRow<S>,
-        returningColumns?: RC
-    ): Promise<TInsertRowResult<S, RC>>;
-
-    insertManyRows<S extends SchemaObject<any>, const RC extends string[]>(
-        table: string,
-        schema: S,
-        rows: TInsertRow<S>[],
-        returningColumns?: RC
-    ): Promise<TInsertManyRowResult<S, RC>>;
-
-    updateRowById<S extends SchemaObject<any>>(
-        table: string,
-        schema: S,
-        id: number | string,
-        row: Partial<TInsertRow<S>>,
-        idColumn?: string
-    ): Promise<TQueryResult<S>>;
-
-    updateManyRows<S extends SchemaObject<any>>(table: string, values: Partial<TInsertRow<S>>, where): Promise<TQueryResult<S>>
-
-    // updateManyRows:  <Entity = TRow>(table: string, values: TInsertRow<Entity>, where: string) => Promise<TQueryResult>,
-}
-
-export type TDatabaseService = {
-    client: TDatabaseClient,
-    buildMigrations: () => TMigrations,
-    buildMigrationLogRepository:  (client: TDatabaseClient) => TMigrationsLogRepository,
-}
-
-export type IsExcludeSaving<T> = T extends SchemaStorageAutoNumber ? true : false;
-
-export type ExcludeExcludeSaveKeys<T> = {
-    [K in keyof T]: IsExcludeSaving<T[K]> extends true ? never : K
-}[keyof T];
-
-export type TInsertRow<S extends SchemaObject> = S extends SchemaObject<infer U> ? {
-     [K in ExcludeExcludeSaveKeys<U>]: S["__infer"][K] 
-} : {};
-