@wabot-dev/framework 0.9.1 → 0.9.5

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 };

package/dist/src/feature/rest-controller/metadata/RestControllerMetadataStore.js

@@ -35,6 +35,9 @@ let RestControllerMetadataStore = class RestControllerMetadataStore {
         }
         methodMiddlewares.unshift(middlewareMetadata);
     }
+    getAllRestControllerConstructors() {
+        return Array.from(this.restControllers.keys());
+    }
     getControllerEndPointsInfo(controllerConstructor) {
         const controller = this.restControllers.get(controllerConstructor);
         if (!controller) {

package/dist/src/feature/socket-controller/metadata/SocketControllerMetadataStore.js

@@ -22,6 +22,9 @@ let SocketControllerMetadataStore = class SocketControllerMetadataStore {
         }
         controllerMiddlewares.unshift(handshakeMetadata);
     }
+    getAllSocketControllerConstructors() {
+        return Array.from(this.socketControllers.keys());
+    }
     getSocketControllerInfo(controllerConstructor) {
         const controller = this.socketControllers.get(controllerConstructor);
         if (!controller) {