@wabot-dev/framework 0.9.2 → 0.9.6

package/dist/src/feature/repository/@repository.js

@@ -0,0 +1,170 @@
+import { container, singleton } from '../../core/injection/index.js';
+import { parseQueryMethodName } from './parseQueryMethodName.js';
+import { RepositoryAdapterRegistry } from './RepositoryAdapterRegistry.js';
+import { RepositoryMetadataStore } from './RepositoryMetadataStore.js';
+
+const RUNTIME_KEY = Symbol('wabot:repositoryRuntime');
+const EXTENSION_KEY = Symbol('wabot:repositoryExtension');
+const AST_CACHE_KEY = Symbol('wabot:repositoryAstCache');
+function getConfig(self) {
+    const ctor = self.constructor;
+    const config = container.resolve(RepositoryMetadataStore).getRepositoryConfig(ctor);
+    if (!config) {
+        throw new Error(`${ctor.name} must be decorated with @repository`);
+    }
+    return config;
+}
+function getRuntime(self) {
+    let runtime = self[RUNTIME_KEY];
+    if (runtime)
+        return runtime;
+    const config = getConfig(self);
+    const adapter = container.resolve(RepositoryAdapterRegistry).getDefault();
+    runtime = adapter.build(config);
+    Object.defineProperty(self, RUNTIME_KEY, { value: runtime, enumerable: false });
+    return runtime;
+}
+function getExtension(self) {
+    const cached = self[EXTENSION_KEY];
+    if (cached !== undefined)
+        return cached;
+    const ctor = self.constructor;
+    const adapter = container.resolve(RepositoryAdapterRegistry).getDefault();
+    const store = container.resolve(RepositoryMetadataStore);
+    const ExtensionCtor = store.getExtension(ctor, adapter.id);
+    if (!ExtensionCtor) {
+        throw new Error(`${ctor.name}.extension is not available: no extension registered ` +
+            `for adapter "${adapter.id.description ?? 'unknown'}". ` +
+            `Import the extension class so its @<adapter>Extension decorator runs, ` +
+            `or check the active adapter.`);
+    }
+    if (typeof adapter.buildExtension !== 'function') {
+        throw new Error(`${ctor.name}.extension cannot be built: adapter ` +
+            `"${adapter.id.description ?? 'unknown'}" does not implement buildExtension().`);
+    }
+    const config = getConfig(self);
+    const ext = adapter.buildExtension(config, ExtensionCtor);
+    Object.defineProperty(self, EXTENSION_KEY, { value: ext, enumerable: false });
+    return ext;
+}
+function installExtensionAccessor(target) {
+    const proto = target.prototype;
+    if (Object.getOwnPropertyDescriptor(proto, 'extension'))
+        return;
+    Object.defineProperty(proto, 'extension', {
+        get() {
+            return getExtension(this);
+        },
+        configurable: true,
+        enumerable: false,
+    });
+}
+function getAst(self, methodName) {
+    let cache = self[AST_CACHE_KEY];
+    if (!cache) {
+        cache = new Map();
+        Object.defineProperty(self, AST_CACHE_KEY, { value: cache, enumerable: false });
+    }
+    let ast = cache.get(methodName);
+    if (!ast) {
+        ast = parseQueryMethodName(methodName);
+        cache.set(methodName, ast);
+    }
+    return ast;
+}
+function makeExtensionImpl(methodName) {
+    return function (...args) {
+        const ext = getExtension(this);
+        const fn = ext[methodName];
+        if (typeof fn !== 'function') {
+            throw new Error(`${this.constructor.name}.${methodName}: ` +
+                `the active adapter's extension does not implement this method.`);
+        }
+        return fn.apply(ext, args);
+    };
+}
+function makeQueryImpl(methodName) {
+    return async function (...args) {
+        const ast = getAst(this, methodName);
+        const runtime = getRuntime(this);
+        switch (ast.prefix) {
+            case 'find':
+                return runtime.runQuery(ast, args);
+            case 'findOne': {
+                const rows = await runtime.runQuery(ast, args);
+                return rows[0] ?? null;
+            }
+            case 'count':
+                return runtime.runCount(ast, args);
+            case 'exists':
+                return runtime.runExists(ast, args);
+            case 'delete':
+                return runtime.runDelete(ast, args);
+        }
+    };
+}
+const CRUD_METHODS = {
+    async find(id) {
+        return getRuntime(this).find(id);
+    },
+    async findOrThrow(id) {
+        return getRuntime(this).findOrThrow(id);
+    },
+    async findByIds(ids) {
+        return getRuntime(this).findByIds(ids);
+    },
+    async findAll() {
+        return getRuntime(this).findAll();
+    },
+    async create(item) {
+        return getRuntime(this).create(item);
+    },
+    async update(item) {
+        return getRuntime(this).update(item);
+    },
+    async delete(item) {
+        return getRuntime(this).delete(item);
+    },
+};
+function installCrudMethods(target) {
+    const proto = target.prototype;
+    for (const [name, fn] of Object.entries(CRUD_METHODS)) {
+        if (Object.prototype.hasOwnProperty.call(proto, name)) {
+            const existing = proto[name];
+            if (typeof existing === 'function')
+                continue;
+        }
+        Object.defineProperty(proto, name, { value: fn, writable: true, configurable: true });
+    }
+}
+function repository(config) {
+    return function (target) {
+        const store = container.resolve(RepositoryMetadataStore);
+        store.saveRepositoryConfig(target, config);
+        installCrudMethods(target);
+        installExtensionAccessor(target);
+        const queryMethods = store.getQueryMethods(target);
+        for (const meta of queryMethods) {
+            if (Object.prototype.hasOwnProperty.call(target.prototype, meta.functionName)) {
+                const existing = target.prototype[meta.functionName];
+                if (typeof existing === 'function' && existing.length > 0) {
+                    continue;
+                }
+            }
+            target.prototype[meta.functionName] = makeQueryImpl(meta.functionName);
+        }
+        const extensionMethods = store.getExtensionMethods(target);
+        for (const meta of extensionMethods) {
+            if (Object.prototype.hasOwnProperty.call(target.prototype, meta.functionName)) {
+                const existing = target.prototype[meta.functionName];
+                if (typeof existing === 'function' && existing.length > 0) {
+                    continue;
+                }
+            }
+            target.prototype[meta.functionName] = makeExtensionImpl(meta.functionName);
+        }
+        singleton()(target);
+    };
+}
+
+export { repository };

package/dist/src/feature/repository/MemoryRepositoryAdapter.js

@@ -0,0 +1,110 @@
+import { generate } from 'short-uuid';
+import { CustomError } from '../../core/error/CustomError.js';
+import '../../core/error/setupErrorHandlers.js';
+import { evaluateQueryAst } from './evaluateQueryAst.js';
+
+function cloneEntity(config, item) {
+    const data = JSON.parse(JSON.stringify(item['data']));
+    return new config.constructor(data);
+}
+class MemoryRepositoryExtension {
+    items;
+    config;
+    constructor(items, config) {
+        this.items = items;
+        this.config = config;
+    }
+    clone(item) {
+        return cloneEntity(this.config, item);
+    }
+}
+class MemoryRepositoryRuntime {
+    items;
+    config;
+    constructor(items, config) {
+        this.items = items;
+        this.config = config;
+    }
+    async find(id) {
+        const item = this.items.get(id);
+        return item ? cloneEntity(this.config, item) : null;
+    }
+    async findOrThrow(id) {
+        const item = await this.find(id);
+        if (!item) {
+            throw new CustomError({
+                message: `Not found ${this.config.constructor.name} with id = '${id}'`,
+                httpCode: 404,
+            });
+        }
+        return item;
+    }
+    async findByIds(ids) {
+        const out = [];
+        for (const id of ids) {
+            const item = this.items.get(id);
+            if (item)
+                out.push(cloneEntity(this.config, item));
+        }
+        return out;
+    }
+    async findAll() {
+        return [...this.items.values()].map((i) => cloneEntity(this.config, i));
+    }
+    async create(item) {
+        if (item.wasCreated()) {
+            throw new Error('Item already created');
+        }
+        item['data'].id = generate();
+        item['data'].createdAt = new Date().getTime();
+        item.validate();
+        this.items.set(item.id, cloneEntity(this.config, item));
+    }
+    async update(item) {
+        item.validate();
+        if (!this.items.has(item.id)) {
+            throw new Error(`Update failed: no affected rows`);
+        }
+        this.items.set(item.id, cloneEntity(this.config, item));
+    }
+    async delete(item) {
+        this.items.delete(item.id);
+    }
+    async runQuery(ast, args) {
+        const result = evaluateQueryAst(this.items.values(), ast, args);
+        return result.map((i) => cloneEntity(this.config, i));
+    }
+    async runCount(ast, args) {
+        return evaluateQueryAst(this.items.values(), ast, args).length;
+    }
+    async runExists(ast, args) {
+        return evaluateQueryAst(this.items.values(), ast, args).length > 0;
+    }
+    async runDelete(ast, args) {
+        const matched = evaluateQueryAst(this.items.values(), ast, args);
+        for (const item of matched) {
+            this.items.delete(item.id);
+        }
+    }
+}
+const MEMORY_ADAPTER_ID = Symbol('wabot:memory-adapter');
+class MemoryRepositoryAdapter {
+    id = MEMORY_ADAPTER_ID;
+    stores = new Map();
+    getStore(config) {
+        let store = this.stores.get(config);
+        if (!store) {
+            store = new Map();
+            this.stores.set(config, store);
+        }
+        return store;
+    }
+    build(config) {
+        return new MemoryRepositoryRuntime(this.getStore(config), config);
+    }
+    buildExtension(config, ExtensionCtor) {
+        return new ExtensionCtor(this.getStore(config), config);
+    }
+}
+
+export { MEMORY_ADAPTER_ID, MemoryRepositoryAdapter, MemoryRepositoryExtension };

package/dist/src/feature/repository/RepositoryAdapterRegistry.js

@@ -0,0 +1,27 @@
+import { __decorate } from 'tslib';
+import { singleton } from '../../core/injection/index.js';
+
+let RepositoryAdapterRegistry = class RepositoryAdapterRegistry {
+    adapter = null;
+    setDefault(adapter) {
+        this.adapter = adapter;
+    }
+    getDefault() {
+        if (!this.adapter) {
+            throw new Error('No repository adapter registered. ' +
+                'Register one with container.resolve(RepositoryAdapterRegistry).setDefault(adapter).');
+        }
+        return this.adapter;
+    }
+    hasDefault() {
+        return this.adapter !== null;
+    }
+    clear() {
+        this.adapter = null;
+    }
+};
+RepositoryAdapterRegistry = __decorate([
+    singleton()
+], RepositoryAdapterRegistry);
+
+export { RepositoryAdapterRegistry };

package/dist/src/feature/repository/RepositoryMetadataStore.js

@@ -0,0 +1,102 @@
+import { __decorate } from 'tslib';
+import { singleton } from '../../core/injection/index.js';
+
+let RepositoryMetadataStore = class RepositoryMetadataStore {
+    queryMethods = new Map();
+    extensionMethods = new Map();
+    repositoryConfigs = new Map();
+    extensions = new Map();
+    saveQueryMethodMetadata(metadata) {
+        let perClass = this.queryMethods.get(metadata.repositoryConstructor);
+        if (!perClass) {
+            perClass = new Map();
+            this.queryMethods.set(metadata.repositoryConstructor, perClass);
+        }
+        perClass.set(metadata.functionName, metadata);
+    }
+    saveExtensionMethodMetadata(metadata) {
+        let perClass = this.extensionMethods.get(metadata.repositoryConstructor);
+        if (!perClass) {
+            perClass = new Map();
+            this.extensionMethods.set(metadata.repositoryConstructor, perClass);
+        }
+        perClass.set(metadata.functionName, metadata);
+    }
+    saveRepositoryConfig(ctor, config) {
+        this.repositoryConfigs.set(ctor, config);
+    }
+    getRepositoryConfig(ctor) {
+        return this.repositoryConfigs.get(ctor);
+    }
+    getQueryMethods(ctor) {
+        return this.collectMethodsFromHierarchy(ctor, this.queryMethods);
+    }
+    getExtensionMethods(ctor) {
+        return this.collectMethodsFromHierarchy(ctor, this.extensionMethods);
+    }
+    collectMethodsFromHierarchy(ctor, source) {
+        const collected = new Map();
+        const hierarchy = [];
+        let proto = ctor.prototype;
+        while (proto && proto.constructor !== Object) {
+            hierarchy.unshift(proto.constructor);
+            proto = Object.getPrototypeOf(proto);
+        }
+        for (const cls of hierarchy) {
+            const perClass = source.get(cls);
+            if (perClass) {
+                for (const [name, meta] of perClass) {
+                    collected.set(name, meta);
+                }
+            }
+        }
+        return [...collected.values()];
+    }
+    saveExtension(repositoryConstructor, adapterId, extensionConstructor) {
+        let perRepo = this.extensions.get(repositoryConstructor);
+        if (!perRepo) {
+            perRepo = new Map();
+            this.extensions.set(repositoryConstructor, perRepo);
+        }
+        const existing = perRepo.get(adapterId);
+        if (existing && existing !== extensionConstructor) {
+            throw new Error(`Extension conflict on ${repositoryConstructor.name}: ` +
+                `adapter "${adapterId.description ?? 'unknown'}" already has ` +
+                `extension ${existing.name}; cannot register ${extensionConstructor.name}.`);
+        }
+        perRepo.set(adapterId, extensionConstructor);
+    }
+    getExtension(ctor, adapterId) {
+        let proto = ctor.prototype;
+        while (proto && proto.constructor !== Object) {
+            const perRepo = this.extensions.get(proto.constructor);
+            if (perRepo) {
+                const ext = perRepo.get(adapterId);
+                if (ext)
+                    return ext;
+            }
+            proto = Object.getPrototypeOf(proto);
+        }
+        return undefined;
+    }
+    validateExtensionsRegistered(adapterId) {
+        const offenders = [];
+        for (const ctor of this.extensionMethods.keys()) {
+            if (!this.getExtension(ctor, adapterId)) {
+                offenders.push(ctor.name);
+            }
+        }
+        if (offenders.length === 0)
+            return;
+        throw new Error(`Repository extension wiring error: the following repositories declare ` +
+            `@queryExtension methods but no extension is registered for adapter ` +
+            `"${adapterId.description ?? 'unknown'}":\n  - ${offenders.join('\n  - ')}\n` +
+            `Did you forget to import the extension classes (so their decorators run), ` +
+            `or are you running with the wrong adapter?`);
+    }
+};
+RepositoryMetadataStore = __decorate([
+    singleton()
+], RepositoryMetadataStore);
+
+export { RepositoryMetadataStore };

package/dist/src/feature/repository/evaluateQueryAst.js

@@ -0,0 +1,134 @@
+function getField(item, field) {
+    return item?.data?.[field];
+}
+function compare(a, b) {
+    if (a == null && b == null)
+        return 0;
+    if (a == null)
+        return -1;
+    if (b == null)
+        return 1;
+    if (typeof a === 'number' && typeof b === 'number')
+        return a - b;
+    return String(a).localeCompare(String(b));
+}
+function likeToRegex(pattern) {
+    let regex = '';
+    for (const ch of pattern) {
+        if (ch === '%')
+            regex += '.*';
+        else if (ch === '_')
+            regex += '.';
+        else
+            regex += ch.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    return new RegExp('^' + regex + '$');
+}
+function operatorArity(op) {
+    if (op === 'IsNull' || op === 'IsNotNull')
+        return 0;
+    return 1;
+}
+function applyOperator(value, op, arg) {
+    switch (op) {
+        case 'Equals':
+            return value == arg;
+        case 'Not':
+            return value != arg;
+        case 'Like':
+            if (value == null)
+                return false;
+            return likeToRegex(String(arg)).test(String(value));
+        case 'NotLike':
+            if (value == null)
+                return false;
+            return !likeToRegex(String(arg)).test(String(value));
+        case 'In':
+            return Array.isArray(arg) && arg.some((x) => x == value);
+        case 'NotIn':
+            return Array.isArray(arg) && !arg.some((x) => x == value);
+        case 'Gt':
+            return value != null && arg != null && compare(value, arg) > 0;
+        case 'Gte':
+            return value != null && arg != null && compare(value, arg) >= 0;
+        case 'Lt':
+            return value != null && arg != null && compare(value, arg) < 0;
+        case 'Lte':
+            return value != null && arg != null && compare(value, arg) <= 0;
+        case 'IsNull':
+            return value == null;
+        case 'IsNotNull':
+            return value != null;
+    }
+}
+function bindArgs(conditions, args) {
+    let expectedArity = 0;
+    for (const c of conditions)
+        expectedArity += operatorArity(c.operator);
+    if (args.length !== expectedArity) {
+        throw new Error(`Query expected ${expectedArity} argument(s), received ${args.length}`);
+    }
+    const bound = [];
+    let idx = 0;
+    for (const cond of conditions) {
+        if (operatorArity(cond.operator) === 0) {
+            bound.push({ cond, arg: undefined });
+        }
+        else {
+            bound.push({ cond, arg: args[idx] });
+            idx += 1;
+        }
+    }
+    return bound;
+}
+// Matches SQL precedence: AND binds tighter than OR.
+// Group consecutive conditions joined by And; start a new group on Or; OR across groups.
+function matches(item, bound) {
+    if (bound.length === 0)
+        return true;
+    const groups = [[]];
+    for (const entry of bound) {
+        if (entry.cond.connector === 'Or' && groups[groups.length - 1].length > 0) {
+            groups.push([entry]);
+        }
+        else {
+            groups[groups.length - 1].push(entry);
+        }
+    }
+    return groups.some((group) => group.every(({ cond, arg }) => applyOperator(getField(item, cond.field), cond.operator, arg)));
+}
+function sortByOrderBy(items, ast) {
+    if (ast.orderBy.length === 0)
+        return items;
+    const copy = [...items];
+    copy.sort((a, b) => {
+        for (const o of ast.orderBy) {
+            const av = getField(a, o.field);
+            const bv = getField(b, o.field);
+            const c = compare(av, bv);
+            if (c !== 0)
+                return o.direction === 'ASC' ? c : -c;
+        }
+        return 0;
+    });
+    return copy;
+}
+function applyLimit(items, ast) {
+    if (ast.prefix === 'findOne')
+        return items.slice(0, 1);
+    if (ast.limit !== undefined)
+        return items.slice(0, ast.limit);
+    return items;
+}
+function evaluateQueryAst(items, ast, args) {
+    const bound = bindArgs(ast.conditions, args);
+    const filtered = [];
+    for (const item of items) {
+        if (matches(item, bound))
+            filtered.push(item);
+    }
+    const sorted = sortByOrderBy(filtered, ast);
+    return applyLimit(sorted, ast);
+}
+
+export { evaluateQueryAst };