@foul11/awesome-db 1.1.0

package/dist/utils.d.ts

@@ -0,0 +1,42 @@
+import type { Kysely } from 'kysely';
+export declare function table_info<DB>(db: Kysely<DB>, table: Extract<keyof DB, string>): Promise<{
+    cid: number;
+    name: string;
+    type: "INTEGER" | "REAL" | "TEXT" | "BLOB" | "NUMERIC";
+    notnull: boolean;
+    dflt_value: string | null;
+    pk: boolean;
+}[]>;
+export declare function master_table(db: Kysely<any>): Promise<{
+    type: "index" | "table";
+    name: string;
+    tbl_name: string;
+    rootpage: number;
+    sql: string;
+}[]>;
+export declare function get_table_schema<DB>(db: Kysely<DB>, table: Extract<keyof DB, string>): Promise<false | {
+    type: "CREATE_TABLE";
+    table: {
+        scheme_parts: string[];
+        name: string;
+    };
+    if_not_exists: boolean;
+    columns: {
+        name: string;
+        type: "TEXT" | "INTEGER" | "REAL" | "BLOB" | "DATETIME";
+        primary: boolean;
+        auto_increment: boolean;
+        not_null: boolean;
+        unique: boolean;
+        default: string | number | null;
+        references: {
+            table: {
+                scheme_parts: string[];
+                name: string;
+            };
+            columns: string[];
+            constraints: string | null;
+        } | null;
+    }[];
+}>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC,wBAAsB,UAAU,CAAC,EAAE,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,MAAM,EAAE,EAAE,MAAM,CAAC;SAKxE,MAAM;UACL,MAAM;UACN,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS;aAC7C,OAAO;gBACJ,MAAM,GAAG,IAAI;QACrB,OAAO;KAElB;AAED,wBAAsB,YAAY,CAAC,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC;UAQpC,OAAO,GAAG,OAAO;UACjB,MAAM;cACF,MAAM;cACN,MAAM;SACX,MAAM;KAElB;AAED,wBAAsB,gBAAgB,CAAC,EAAE,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,MAAM,EAAE,EAAE,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;GAY1F"}

package/eslint.config.js

@@ -0,0 +1,7 @@
+import baseConfig from '@foul11/awesome-eslint-config/base';
+import nodeConfig from '@foul11/awesome-eslint-config/node';
+
+export default [
+    ...baseConfig,
+    ...nodeConfig,
+];

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@foul11/awesome-db",
+  "version": "1.1.0",
+  "type": "module",
+  "main": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "test": "jest",
+    "build": "awesome-tools webpack -t lib",
+    "watch": "awesome-tools webpack -t lib -w",
+    "eslint": "eslint . --max-warnings=0",
+    "clean": "rm -rf dist"
+  },
+  "devDependencies": {
+    "@foul11/awesome-eslint-config": "1.1.0",
+    "@foul11/awesome-log": "1.1.0",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/bindings": "^1.5.5",
+    "better-sqlite3": "^12.9.0",
+    "kysely": "^0.29.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [],
+  "author": "foul11",
+  "license": "MIT",
+  "packageManager": "pnpm@10.32.1",
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node",
+    "passWithNoTests": true
+  },
+  "dependencies": {
+    "@foul11/awesome": "1.1.0",
+    "@foul11/sql-formatter": "^15.7.3",
+    "better-sqlite3-expert": "^1.0.2",
+    "bindings": "^1.5.0",
+    "deepmerge": "^4.3.1",
+    "type-fest": "^5.6.0",
+    "uuid": "^14.0.0"
+  },
+  "peerDependencies": {
+    "@foul11/awesome-log": "workspace:*",
+    "better-sqlite3": "^12.9.0",
+    "kysely": "^0.29.0"
+  },
+  "peerDependenciesMeta": {
+    "@foul11/awesome-log": {
+      "optional": true
+    }
+  },
+  "gitHead": "44ef083589e3ffaaa148f4ba485ef000dc09d9d7"
+}

package/src/BitFields.ts

@@ -0,0 +1,160 @@
+/* eslint-disable @typescript-eslint/no-use-before-define */
+import { ErrorFlagPack, ErrorFlagUnpack } from './Error';
+
+import type { DrainOuterGeneric } from 'kysely';
+import type { IntRange } from 'type-fest';
+
+type RecursiveChangeType<T, T_FROM, T_TO> = DrainOuterGeneric<{
+    [K in keyof T]: T[K] extends T_FROM
+        ? T_TO
+        : (
+            T[K] extends Record<string, any>
+                ? RecursiveChangeType<T[K], T_FROM, T_TO>
+                : never
+        );
+}>;
+
+type RecursiveObject<T, FIELD_TYPE> = DrainOuterGeneric<{
+    [K in keyof T]:
+        | RecursiveObject<T[K], FIELD_TYPE>
+        | FIELD_TYPE;
+}>;
+
+type RecursiveUndefinedToOptional<T> = DrainOuterGeneric<{
+    [K in keyof T]?: RecursiveUndefinedToOptional<T[K]>;
+}>;
+
+type Guarded<F> =
+    F extends (x: any) => x is infer T ? T : never;
+
+export type BitFieldsScheme<
+    Range extends IntRange<0, 52> = Guarded<typeof BitFields['isValidField']>,
+> = RecursiveObject<
+    { [key: string]: any },
+    Range
+>;
+
+export type BitFieldsUnpack<T extends BitFieldsScheme> = (
+    RecursiveUndefinedToOptional<
+        RecursiveChangeType<T, number, boolean | undefined>
+    >
+);
+
+function unpack<
+    BIT_SCHEME extends BitFieldsScheme,
+    BIT_UNPACK,
+>(flags: number, from: BIT_SCHEME): BIT_UNPACK {
+    const to: any = {};
+    
+    for (const [ key, val ] of Object.entries(from)) {
+        switch (true) {
+            case typeof val == 'number':
+                if (!BitFields.isValidField(val))
+                    throw new ErrorFlagUnpack(`Out of range: pos {${val as any}}`);
+                to[key] = BitFields.getBit(flags, val);
+                break;
+            
+            case typeof val == 'object':
+                to[key] = unpack(flags, val as any);
+                break;
+            
+            default:
+                throw new ErrorFlagUnpack(`Invalid type {${typeof val}}`);
+        }
+    }
+    
+    return to;
+}
+    
+function pack<
+    BIT_SCHEME extends BitFieldsScheme,
+    BIT_UNPACK extends BitFieldsUnpack<BIT_SCHEME>,
+>(flags: Partial<BIT_UNPACK>, to: number, from: BIT_SCHEME): number {
+    for (const [ key, val ] of Object.entries(from)) {
+        switch (true) {
+            case typeof val == 'number':
+                if (flags && key in flags) {
+                    if (!BitFields.isValidField(val))
+                        throw new ErrorFlagUnpack(`Out of range: pos {${val as any}}`);
+                    to = BitFields.setBit((flags as any)[key], val, to);
+                }
+                break;
+                
+            case typeof val == 'object':
+                if (flags && key in flags) {
+                    to = pack((flags as any)[key], to, val as any);
+                }
+                break;
+                
+            default:
+                throw new ErrorFlagPack(`Invalid type {${typeof val}}`);
+        }
+    }
+    
+    return to;
+}
+
+    
+function toFlat<
+    BIT_SCHEME extends BitFieldsScheme,
+    INPUT extends (
+        | BIT_SCHEME
+        | BitFieldsUnpack<BIT_SCHEME>
+    ),
+>(flags: INPUT, paths: string[] = []): string[] {
+    const out: string[] = [];
+    
+    for (const [ key, val ] of Object.entries(flags)) {
+        switch (true) {
+            case typeof val == 'object':
+                out.push(...toFlat(val, [ ...paths, key ]));
+                break;
+            
+            case typeof val == 'number':
+            case typeof val == 'boolean' && val:
+                out.push([ ...paths, key ].join('.'));
+                break;
+        }
+    }
+    
+    return out;
+}
+
+export class BitFields<
+    BIT_SCHEME extends BitFieldsScheme,
+    BIT_UNPACK extends BitFieldsUnpack<BIT_SCHEME> = BitFieldsUnpack<BIT_SCHEME>,
+> {
+    bitScheme: BIT_SCHEME;
+    
+    constructor(flag_bits: BIT_SCHEME) {
+        this.bitScheme = flag_bits;
+    }
+    
+    static getBit(input: number, pos: number): boolean {
+        return !!((input >> pos) & 0x01);
+    }
+    
+    static setBit(bit: boolean, pos: number, input = 0): number {
+        return bit ? (input | (1 << pos)) : (input & ~(1 << pos));
+    }
+    
+    static isValidField(input: number): input is IntRange<0, 52> {
+        return typeof input == 'number' && input >= 0 && input < 52;
+    }
+    
+    unpack(flags: number): BIT_UNPACK {
+        return unpack<BIT_SCHEME, BIT_UNPACK>(flags, this.bitScheme);
+    }
+    
+    pack(flags: BIT_UNPACK, to = 0): number {
+        return pack<BIT_SCHEME, BIT_UNPACK>(flags, to, this.bitScheme);
+    }
+    
+    list(): string[] {
+        return toFlat<BIT_SCHEME, BIT_SCHEME>(this.bitScheme);
+    }
+    
+    unpackToList(flags: number): string[] {
+        return toFlat<BIT_SCHEME, BIT_UNPACK>(this.unpack(flags));
+    }
+}

package/src/Error.ts

@@ -0,0 +1,13 @@
+export class ErrorModule extends Error {}
+
+export class ErrorDB extends ErrorModule {}
+
+export class ErrorMigration extends ErrorDB {}
+export class ErrorSchema extends ErrorDB {}
+export class ErrorQuery extends ErrorDB {}
+export class ErrorUnknown extends ErrorDB {}
+
+export class ErrorFlag extends ErrorUnknown {}
+export class ErrorFlagPack extends ErrorFlag {}
+export class ErrorFlagUnpack extends ErrorFlag {}
+export class ErrorFlagInvalid extends ErrorFlag {}

package/src/ORM.ts

@@ -0,0 +1,49 @@
+import { ErrorUnknown } from './Error';
+
+import type { AnyColumn, Kysely, SelectType, UpdateKeys } from 'kysely';
+
+type KeysMatching<T, V> = {
+    [K in keyof T]-?: T[K] extends V ? K : never
+}[keyof T];
+
+export class ORM {
+    static async getWhereId<
+        DB,
+        TB extends KeysMatching<DB, { id: any }>,
+        CN extends AnyColumn<DB, TB>,
+    >(
+        id: number,
+        table: TB,
+        column: CN,
+        db_builder: Kysely<DB>,
+    ): Promise<SelectType<DB[TB][CN]>> {
+        const res = await (db_builder as any)
+            .selectFrom(table)
+            .select(column as any)
+            .where('id', '=', id as any)
+            .executeTakeFirst();
+        
+        if (!res)
+            throw new ErrorUnknown(`Failed to get column ${String(column)} from ${String(table)}`);
+        
+        return (res as any)[column];
+    }
+    
+    static async setWhereId<
+        DB,
+        TB extends KeysMatching<DB, { id: any }>,
+        UCN extends UpdateKeys<DB[TB]>,
+    >(
+        id: number,
+        table: TB,
+        value: UCN,
+        db_builder: Kysely<DB>,
+    ): Promise<boolean> {
+        const result = await (db_builder as any)
+            .updateTable(table as any)
+            .set(value)
+            .where('id', '=', id as any)
+            .executeTakeFirst();
+        return result.numUpdatedRows == 1n;
+    }
+}