@foul11/awesome-db 1.1.0

package/src/tables/Permission/index.ts

@@ -0,0 +1,220 @@
+export * from './schema';
+
+import { master_table } from '../../utils';
+import { ORM } from '../../ORM';
+
+import type { Kysely } from 'kysely';
+import type { DBTablesByType } from '../../types';
+import type { TablePermission, TablePermissionGroup } from './schema';
+
+type DefaultKeyPermission = 'permission';
+interface DefaultKyselyPermission {
+    permission: TablePermission
+}
+
+export interface PermissionStore {
+    getPermissions(id: number): Promise<string[]>
+    hasPermission(id: number, permission: string): Promise<boolean>
+    addPermission(id: number, permission: string): Promise<void>
+    delPermission(id: number, permission: string): Promise<void>
+}
+
+export class PermissionStoreDB implements PermissionStore {
+    protected readonly db: Kysely<DefaultKyselyPermission>;
+    protected readonly domain: DefaultKeyPermission;
+    
+    private constructor(db: any, domain: any) {
+        this.db = db;
+        this.domain = domain;
+    }
+    
+    static async create<
+        DB,
+        Domain extends DBTablesByType<DB, TablePermission>,
+    >(
+        db: Kysely<DB>,
+        domain: Domain,
+    ) {
+        const master = await master_table(db);
+        const info = master.find(r => r.name == domain && r.type == 'table');
+        
+        if (!info)
+            throw new Error(`Table ${domain} not found, can't create permission store`);
+        
+        return new PermissionStoreDB(db, domain);
+    }
+    
+    async getPermissions(id: number): Promise<string[]> {
+        return (
+            await this.db
+                .selectFrom(this.domain)
+                .select('name')
+                .where('fk_id', '=', id)
+                .execute()
+        ).map(r => r.name);
+    }
+    
+    async hasPermission(id: number, permission: string): Promise<boolean> {
+        const perms_chunks = permission.split('.');
+        const perms = [];
+        
+        for (let i = 0; i < perms_chunks.length; i++) {
+            perms.push(perms_chunks.slice(0, i + 1).join('.'));
+        }
+        
+        return !!(
+            await this.db
+                .selectFrom(this.domain)
+                .select(eb => eb.lit(true).as('exists'))
+                .where('name', 'in', perms)
+                .where('fk_id', '=', id)
+                .executeTakeFirst()
+        )?.exists;
+    }
+    
+    async addPermission(id: number, permission: string): Promise<void> {
+        return void (
+            await this.db
+                .insertInto(this.domain)
+                .values({
+                    fk_id: id,
+                    name: permission,
+                })
+                .onConflict(oc => oc
+                    .doNothing())
+                .executeTakeFirst()
+        );
+    }
+    
+    async delPermission(id: number, permission: string): Promise<void> {
+        return void (
+            await this.db
+                .deleteFrom(this.domain)
+                .where('fk_id', '=', id)
+                .where('name', '=', permission)
+                .executeTakeFirst()
+        );
+    }
+}
+
+export class Permission extends ORM {
+    protected readonly parent: Permission | undefined;
+    protected readonly store: PermissionStore;
+    protected readonly name: string;
+    protected readonly children: Map<string, Permission> = new Map();
+    
+    protected constructor(store: PermissionStore, name: string, parent?: Permission) {
+        super();
+        
+        this.parent = parent;
+        this.store = store;
+        this.name = name;
+        
+        if (!/^[a-zA-Z0-9_-]+$/.test(this.name))
+            throw new Error('Invalid permission name');
+    }
+    
+    static newRoot(options: {
+        store: PermissionStore
+        name?: string
+    }): Permission {
+        return new Permission(options.store, options.name || 'root');
+    }
+    
+    static async has(id: number, perm: Permission): Promise<boolean> {
+        return perm.store.hasPermission(id, perm.getFullName());
+    }
+    
+    static async add(id: number, perm: Permission): Promise<void> {
+        return perm.store.addPermission(id, perm.getFullName());
+    }
+    
+    static async del(id: number, perm: Permission): Promise<void> {
+        return perm.store.delPermission(id, perm.getFullName());
+    }
+    
+    getFlatPermissions(): string[] {
+        const result = [
+            this.getFullName(),
+        ];
+        
+        for (const child of this.children.values())
+            result.push(...child.getFlatPermissions());
+        
+        return result;
+    }
+    
+    getFullName(): string {
+        if (!this.parent)
+            return this.name;
+        
+        return this.parent.getFullName() + '.' + this.name;
+    }
+    
+    child(name: string) {
+        const child = new Permission(this.store, name, this);
+        
+        this.children.set(name, child);
+        
+        return child;
+    }
+}
+
+// export class PermissionGroup {
+//     // Domain -> Set<PermissionName> Что бы не допускать дубликатов
+//     static groups: Map<string, Set<string>> = new Map();
+    
+//     include_permissions: (Permission | PermissionGroup)[];
+//     exclude_permissions: (Permission | PermissionGroup)[];
+    
+//     domain: string;
+//     name: string;
+    
+//     constructor(domain: string, name: string) {
+//         this.domain = domain;
+//         this.name = name;
+        
+//         this.include_permissions = [];
+//         this.exclude_permissions = [];
+//     }
+    
+//     hasIncludePermission(perm: Permission): boolean {
+//         return false;
+//     }
+    
+//     hasExcludePermission(perm: Permission): boolean {
+//         return false;
+//     }
+    
+//     hasPermission(perm: Permission): boolean {
+//         return this.hasIncludePermission(perm) && !this.hasExcludePermission(perm);
+//     }
+// }
+
+
+// const perm_root = Permission.newRoot('user-permission');
+
+// const perm_crm = perm_root.child('CRM');
+// const perm_crm_user = perm_crm.child('user');
+
+// const perm_users_list = perm_crm_user.child('list');
+// const perm_users_view = perm_crm_user.child('view');
+// const perm_users_add = perm_crm_user.child('add');
+// const perm_users_edit = perm_crm_user.child('edit');
+// const perm_users_remove = perm_crm_user.child('remove');
+
+// const User = {} as any;
+
+// User.hasPermission = function (perm: Permission) {
+//     if (Permission.has(User.id, perm_root))
+//         return true;
+    
+//     if (Permission.has(User.id, perm))
+//         return true;
+    
+//     return false;
+// };
+
+// if (User.hasPermission(perm_users_list)) {
+//     //
+// }

package/src/tables/Permission/schema.ts

@@ -0,0 +1,13 @@
+import type { Generated, GeneratedAlways } from 'kysely';
+
+export interface TablePermission {
+    id:         Generated<number>
+    fk_id:      number  // fk, id к которому принадлежит право
+    name:       string  // fullName
+    created_at: GeneratedAlways<string>
+}
+
+export interface TablePermissionGroup {
+    id:         Generated<number>
+    created_at: GeneratedAlways<string>
+}

package/src/tables/SetString/index.ts

@@ -0,0 +1,45 @@
+export * from './schema';
+
+import { ORM } from '../../ORM';
+
+import type { Kysely } from 'kysely';
+import type { DBTablesByType } from '../../types';
+import type { TableSetString } from './schema';
+
+type DefaultKeySetString = 'default_set';
+interface DefaultKyselySetString {
+    default_set: TableSetString
+}
+
+export class SetString extends ORM {
+    static async store_value_or_throw<
+        DB,
+        Domain extends DBTablesByType<DB, TableSetString> = DBTablesByType<DB, TableSetString>,
+    >(value: string, domain: Domain, db_builder: Kysely<DB>): Promise<number> {
+        const db = db_builder as unknown as Kysely<DefaultKyselySetString>;
+        const in_domain = domain as DefaultKeySetString;
+        
+        return (
+            await db
+                .insertInto(in_domain)
+                .returning('id')
+                .values({
+                    value,
+                })
+                .onConflict(oc => oc
+                    // .doNothing() // Не возвращает id, если строка уже была в базе: https://sqlite.org/forum/info/6b14076446260538
+                    .doUpdateSet(eb => ({
+                        id: eb.ref('id'),
+                    })),
+                )
+                .executeTakeFirstOrThrow()
+        ).id;
+    }
+    
+    static async try_store_value_or_throw<
+        DB,
+        Domain extends DBTablesByType<DB, TableSetString> = DBTablesByType<DB, TableSetString>,
+    >(value: string | undefined, domain: Domain, db_builder: Kysely<DB>): Promise<number | undefined> {
+        return value ? await this.store_value_or_throw(value, domain, db_builder) : undefined;
+    }
+}

package/src/tables/SetString/schema.ts

@@ -0,0 +1,7 @@
+import type { Generated, GeneratedAlways } from 'kysely';
+
+export interface TableSetString {
+    id:         Generated<number>
+    value:      string  // unique
+    created_at: GeneratedAlways<string>
+}

package/src/tables/Settings/index.ts

@@ -0,0 +1,135 @@
+export * from './schema';
+
+import { master_table } from '../../utils';
+import { ORM } from '../../ORM';
+
+import type { Kysely } from 'kysely';
+import type { DBTablesByType } from '../../types';
+import type { TableSettings } from './schema';
+
+type DefaultKeyPermission = 'settings';
+interface DefaultKyselyPermission {
+    settings: TableSettings
+}
+
+export interface SettingsStore {
+    getKV(key: string): Promise<string | undefined>
+    setKV(key: string, value: string): Promise<void>
+    hasKV(key: string): Promise<boolean>
+    unsetKV(key: string): Promise<void>
+}
+
+export class SettingsStoreDB implements SettingsStore {
+    protected readonly db: Kysely<DefaultKyselyPermission>;
+    protected readonly domain: DefaultKeyPermission;
+    
+    private constructor(db: any, domain: any) {
+        this.db = db;
+        this.domain = domain;
+    }
+    
+    static async create<
+        DB,
+        Domain extends DBTablesByType<DB, TableSettings>,
+    >(
+        db: Kysely<DB>,
+        domain: Domain,
+    ) {
+        const master = await master_table(db);
+        const info = master.find(r => r.name == domain && r.type == 'table');
+        
+        if (!info)
+            throw new Error(`Table ${domain} not found, can't create settings store`);
+        
+        return new SettingsStoreDB(db, domain);
+    }
+    
+    async getKV(key: string): Promise<any> {
+        return (
+            await this.db
+                .selectFrom(this.domain)
+                .select('value')
+                .where('key', '=', key)
+                .executeTakeFirst()
+        )?.value;
+    }
+    
+    async setKV(key: string, value: string): Promise<void> {
+        return void (
+            await this.db
+                .insertInto(this.domain)
+                .values({
+                    key,
+                    value,
+                })
+                .onConflict(oc => oc
+                    .doUpdateSet({ value }))
+                .executeTakeFirst()
+        );
+    }
+    
+    async hasKV(key: string): Promise<boolean> {
+        return (
+            await this.db
+                .selectFrom(this.domain)
+                .select('id')
+                .where('key', '=', key)
+                .executeTakeFirst()
+        ) != null;
+    }
+    
+    async unsetKV(key: string): Promise<void> {
+        return void (
+            await this.db
+                .deleteFrom(this.domain)
+                .where('key', '=', key)
+                .executeTakeFirst()
+        );
+    }
+}
+
+type DefaultsObject = {
+    [key: string]: any
+};
+
+export class Settings<SettingsObject extends DefaultsObject> extends ORM {
+    protected readonly store: SettingsStore;
+    protected readonly defaults: SettingsObject;
+    
+    private constructor(store: SettingsStore, defaults: any) {
+        super();
+        
+        this.store = store;
+        this.defaults = defaults;
+    }
+    
+    static new<
+        Defaults extends DefaultsObject,
+    >(options: {
+        store: SettingsStore
+        defaults: Defaults
+    }) {
+        return new Settings<Defaults>(options.store, options.defaults);
+    }
+    
+    async get<K extends keyof SettingsObject>(key: K & string): Promise<SettingsObject[K]> {
+        const value = await this.store.getKV(key);
+        
+        if (value !== undefined)
+            return JSON.parse(value);
+        
+        return this.defaults[key];
+    }
+    
+    async set<K extends keyof SettingsObject>(key: K & string, value: SettingsObject[K]): Promise<void> {
+        await this.store.setKV(key, JSON.stringify(value));
+    }
+    
+    async unset<K extends keyof SettingsObject>(key: K & string): Promise<void> {
+        await this.store.unsetKV(key);
+    }
+    
+    async has<K extends keyof SettingsObject>(key: K & string): Promise<boolean> {
+        return await this.store.hasKV(key);
+    }
+}

package/src/tables/Settings/schema.ts

@@ -0,0 +1,8 @@
+import type { Generated, GeneratedAlways } from 'kysely';
+
+export interface TableSettings {
+    id:         Generated<number>
+    key:        string  // unique
+    value:      string  // JSON
+    created_at: GeneratedAlways<string>
+}