@ug.software/opposer 3.0.10 → 3.0.11

package/lib/cjs/orm/repository.js

@@ -1,325 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Repository = void 0;
-const metadata_js_1 = require("./metadata.js");
-const query_builder_js_1 = require("./query-builder.js");
-const crypto_1 = __importDefault(require("crypto"));
-class Repository {
-    constructor(connection, target) {
-        this.connection = connection;
-        this.target = target;
-        const metadata = metadata_js_1.MetadataStore.getEntity(target);
-        const fields = metadata_js_1.MetadataStore.getFields(target);
-        if (!metadata) {
-            throw new Error(`Entity metadata not found for ${target.name}`);
-        }
-        this.metadata = metadata;
-        this.fields = fields;
-        this.translator = new query_builder_js_1.QueryTranslator(this.metadata, this.fields, this.connection.getDriver());
-    }
-    get Metadata() {
-        return this.metadata;
-    }
-    get Fields() {
-        return this.fields;
-    }
-    async find(options) {
-        const driver = this.connection.getDriver();
-        const selectParts = [];
-        // Main entity select
-        selectParts.push(this.translator.translateSelect(options.select || []));
-        // Relations
-        const relationResult = this.translator.translateRelations(options.relation || []);
-        if (relationResult.select.length > 0) {
-            selectParts.push(...relationResult.select);
-        }
-        const { sql: where, params, joins: whereJoins } = this.translator.translateFilter(options.where || {});
-        const pagination = this.translator.translatePagination(options.pagination);
-        const allJoins = new Set(relationResult.joins);
-        // Add missing joins from where clause
-        if (whereJoins.size > 0) {
-            const neededJoins = Array.from(whereJoins);
-            // We need to translate these joins if they are not already in allJoins
-            // For simplicity, let's assume translateRelations can be called for individual relations
-            const missingJoinsResult = this.translator.translateRelations(neededJoins.filter(rj => !options.relation?.some(r => (typeof r === 'string' ? r === rj : r.model === rj))));
-            missingJoinsResult.joins.forEach(j => allJoins.add(j));
-        }
-        const joinsSql = Array.from(allJoins).join(' ');
-        const sql = `SELECT ${selectParts.join(', ')} FROM ${driver.quoteIdentifier(this.metadata.tableName)} ${joinsSql} ${where} ${pagination};`;
-        const results = await driver.query(sql, params);
-        const primaryFields = this.fields.filter((f) => f.primary);
-        const entitiesMap = new Map();
-        for (const row of results) {
-            const pk = primaryFields.map((f) => row[f.name]).join(':');
-            if (!entitiesMap.has(pk)) {
-                entitiesMap.set(pk, this.reconstruct(row));
-            }
-            else {
-                const existing = entitiesMap.get(pk);
-                this.merge(existing, row);
-            }
-        }
-        return Array.from(entitiesMap.values());
-    }
-    async findOne(options) {
-        const results = await this.find({
-            ...options,
-            pagination: { page: 0, take: 1 },
-        });
-        return results.length > 0 ? results[0] : null;
-    }
-    reconstruct(row) {
-        const entity = new this.target();
-        this.merge(entity, row);
-        return entity;
-    }
-    merge(entity, row) {
-        for (const [key, value] of Object.entries(row)) {
-            if (key.includes('.')) {
-                const parts = key.split('.');
-                let current = entity;
-                let currentTarget = this.target;
-                for (let i = 0; i < parts.length - 1; i++) {
-                    const part = parts[i];
-                    const relationField = metadata_js_1.MetadataStore.getFields(currentTarget).find((f) => f.name === part);
-                    if (relationField && relationField.relation) {
-                        const isArray = relationField.relation.type === 'one-to-many' || relationField.relation.type === 'many-to-many';
-                        const nextTarget = relationField.relation.target();
-                        if (isArray) {
-                            if (!Array.isArray(current[part])) {
-                                current[part] = [];
-                            }
-                            // We need to find if the item already exists in the array
-                            // To do that we need the primary key of the target entity
-                            const targetFields = metadata_js_1.MetadataStore.getFields(nextTarget);
-                            const targetPrimaryFields = targetFields.filter(f => f.primary);
-                            // Find child row values for child PK
-                            const childPkValues = {};
-                            let hasAnyValue = false;
-                            targetPrimaryFields.forEach(pf => {
-                                const fullKey = [...parts.slice(0, i + 1), pf.name].join('.');
-                                if (row[fullKey] !== undefined && row[fullKey] !== null) {
-                                    childPkValues[pf.name] = row[fullKey];
-                                    hasAnyValue = true;
-                                }
-                            });
-                            if (!hasAnyValue) {
-                                // If all PK fields of the relation are null, it means there's no related record (LEFT JOIN result)
-                                break;
-                            }
-                            let existingChild = current[part].find((item) => {
-                                return targetPrimaryFields.every(pf => item[pf.name] === childPkValues[pf.name]);
-                            });
-                            if (!existingChild) {
-                                existingChild = new nextTarget();
-                                current[part].push(existingChild);
-                            }
-                            current = existingChild;
-                            currentTarget = nextTarget;
-                        }
-                        else {
-                            if (typeof current[part] === 'string' || current[part] === undefined || current[part] === null) {
-                                const id = typeof current[part] === 'string' ? current[part] : undefined;
-                                current[part] = id ? { id } : new nextTarget();
-                            }
-                            current = current[part];
-                            currentTarget = nextTarget;
-                        }
-                    }
-                    else {
-                        // Fallback for non-metadata relations (should not happen with decorators)
-                        if (current[part] === undefined || current[part] === null) {
-                            current[part] = {};
-                        }
-                        current = current[part];
-                    }
-                }
-                const lastPart = parts[parts.length - 1];
-                if (value !== null || current[lastPart] === undefined) {
-                    current[lastPart] = value;
-                }
-            }
-            else {
-                if (value === null && typeof entity[key] === 'object' && entity[key] !== null) {
-                    continue;
-                }
-                entity[key] = value;
-            }
-        }
-    }
-    async executeHooks(type, entity) {
-        const hooks = metadata_js_1.MetadataStore.getHooks(this.target).filter((h) => {
-            return h.type === type;
-        });
-        for (const hook of hooks) {
-            const method = entity[hook.propertyKey];
-            if (typeof method === 'function') {
-                await method.apply(entity);
-            }
-        }
-    }
-    async insert(data) {
-        const entity = Object.assign(new this.target(), data);
-        // Execute hooks
-        await this.executeHooks('before-insert', entity);
-        const persistableFields = metadata_js_1.MetadataStore.getPersistableFields(this.target);
-        const now = new Date();
-        for (const field of persistableFields) {
-            if (field.createDate || field.updateDate) {
-                if (entity[field.name] === undefined) {
-                    entity[field.name] = now;
-                }
-            }
-            if (field.generated && field.type === 'uuid' && entity[field.name] === undefined) {
-                entity[field.name] = crypto_1.default.randomUUID();
-            }
-        }
-        const persistableKeys = persistableFields.map((f) => {
-            return f.name;
-        });
-        const keys = Object.keys(entity).filter((k) => {
-            return persistableKeys.includes(k) || k === 'id';
-        });
-        const values = keys.map((k) => {
-            return entity[k];
-        });
-        const driver = this.connection.getDriver();
-        const placeholders = keys
-            .map((_, i) => {
-            return `$${i + 1}`;
-        })
-            .join(', ');
-        const columns = keys
-            .map((k) => {
-            return driver.quoteIdentifier(k);
-        })
-            .join(', ');
-        const isSqlite = driver.constructor.name === 'SQLiteDriver';
-        if (isSqlite) {
-            const sql = `INSERT INTO ${driver.quoteIdentifier(this.metadata.tableName)} (${columns}) VALUES (${placeholders});`;
-            await driver.query(sql, values);
-            // Fetch the inserted record using primary key(s)
-            const primaryFields = this.fields.filter((f) => {
-                return f.primary;
-            });
-            const where = {};
-            primaryFields.forEach((f) => {
-                where[f.name] = entity[f.name];
-            });
-            return (await this.findOne({ where }));
-        }
-        else {
-            const sql = `INSERT INTO ${driver.quoteIdentifier(this.metadata.tableName)} (${columns}) VALUES (${placeholders}) RETURNING *;`;
-            const result = await driver.query(sql, values);
-            return result[0];
-        }
-    }
-    async update(where, data) {
-        const entity = Object.assign(new this.target(), data);
-        await this.executeHooks('before-update', entity);
-        const persistableFields = metadata_js_1.MetadataStore.getPersistableFields(this.target);
-        const now = new Date();
-        for (const field of persistableFields) {
-            if (field.updateDate) {
-                entity[field.name] = now;
-            }
-        }
-        const driver = this.connection.getDriver();
-        const persistableKeys = persistableFields.map((f) => {
-            return f.name;
-        });
-        const setKeys = Object.keys(entity).filter((k) => {
-            return persistableKeys.includes(k);
-        });
-        const setValues = setKeys.map((k) => {
-            return entity[k];
-        });
-        const setSql = setKeys
-            .map((k, i) => {
-            return `${driver.quoteIdentifier(k)} = $${i + 1}`;
-        })
-            .join(', ');
-        const { sql: whereSql, params: whereParams } = this.translator.translateFilter(where);
-        // Adjust whereParams placeholders
-        const adjustedWhereSql = whereSql.replace(/\$(\d+)/g, (_, n) => {
-            return `$${parseInt(n) + setValues.length}`;
-        });
-        const sql = `UPDATE ${driver.quoteIdentifier(this.metadata.tableName)} SET ${setSql} ${adjustedWhereSql};`;
-        await driver.query(sql, [...setValues, ...whereParams]);
-    }
-    async delete(where) {
-        const driver = this.connection.getDriver();
-        const { sql: whereSql, params } = this.translator.translateFilter(where);
-        const sql = `DELETE FROM ${driver.quoteIdentifier(this.metadata.tableName)} ${whereSql};`;
-        await driver.query(sql, params);
-    }
-    async count(where) {
-        const driver = this.connection.getDriver();
-        const { sql: whereSql, params } = this.translator.translateFilter(where);
-        const sql = `SELECT COUNT(*) as count FROM ${driver.quoteIdentifier(this.metadata.tableName)} ${whereSql};`;
-        const result = await driver.query(sql, params);
-        return parseInt(result[0].count);
-    }
-    async exists(where) {
-        const driver = this.connection.getDriver();
-        const { sql: whereSql, params } = this.translator.translateFilter(where);
-        const sql = `SELECT 1 FROM ${driver.quoteIdentifier(this.metadata.tableName)} ${whereSql} LIMIT 1;`;
-        const result = await driver.query(sql, params);
-        return result.length > 0;
-    }
-    async aggregate(options) {
-        const driver = this.connection.getDriver();
-        const { sql: whereSql, params } = this.translator.translateFilter(options.where || {});
-        const aggregateSql = this.translator.translateAggregate(options.aggregate);
-        const sql = `SELECT ${aggregateSql} FROM ${driver.quoteIdentifier(this.metadata.tableName)} ${whereSql};`;
-        const result = await driver.query(sql, params);
-        return result[0];
-    }
-    async distinct(options) {
-        const driver = this.connection.getDriver();
-        const { sql: whereSql, params } = this.translator.translateFilter(options.where || {});
-        const sql = `SELECT DISTINCT ${driver.quoteIdentifier(options.field)} FROM ${driver.quoteIdentifier(this.metadata.tableName)} ${whereSql};`;
-        const result = await driver.query(sql, params);
-        return result.map((r) => {
-            return r[options.field];
-        });
-    }
-    async group(options) {
-        const driver = this.connection.getDriver();
-        const { sql: whereSql, params } = this.translator.translateFilter(options.where || {});
-        const groupSql = this.translator.translateGroup(options.by);
-        let selectParts = [];
-        if (options.select) {
-            selectParts.push(this.translator.translateSelect(options.select));
-        }
-        else {
-            selectParts.push(options.by
-                .map((f) => {
-                return driver.quoteIdentifier(f);
-            })
-                .join(', '));
-        }
-        if (options.aggregate) {
-            selectParts.push(this.translator.translateAggregate(options.aggregate));
-        }
-        const sql = `SELECT ${selectParts.join(', ')} FROM ${driver.quoteIdentifier(this.metadata.tableName)} ${whereSql} ${groupSql};`;
-        return await driver.query(sql, params);
-    }
-    validate(data) {
-        const errors = {};
-        for (const field of this.fields) {
-            if (field.validation) {
-                const val = field.validation();
-                const fieldErrors = val.validate(data[field.name], data);
-                if (fieldErrors && fieldErrors.length > 0) {
-                    errors[field.name] = fieldErrors;
-                }
-            }
-        }
-        return errors;
-    }
-}
-exports.Repository = Repository;

package/lib/cjs/orm/validation.d.ts

@@ -1,44 +0,0 @@
-export type ValidationFunction = (value: unknown, context: object) => string | null;
-export declare class FieldValidator {
-    protected _type: string | null;
-    protected _cases: ValidationFunction[];
-    protected _default: any;
-    get type(): string | null;
-    get defaultValue(): any;
-    default(value: any): this;
-    when(test: ValidationFunction): this;
-    validate(value: unknown, context: object): string[];
-}
-declare class NumberValidator extends FieldValidator {
-    constructor(message: string);
-    required(message: string): this;
-    min(min: number, message: string): this;
-    max(max: number, message: string): this;
-}
-declare class StringValidator extends FieldValidator {
-    constructor(message: string);
-    required(message: string): this;
-    match(regex: RegExp, message: string): this;
-}
-declare class BooleanValidator extends FieldValidator {
-    constructor(message: string);
-    required(message: string): this;
-}
-declare class DateValidator extends FieldValidator {
-    constructor(message: string);
-    required(message: string): this;
-}
-declare class JsonValidator extends FieldValidator {
-    private children?;
-    constructor(children?: Record<string, FieldValidator> | undefined);
-    validate(value: any, context: object): string[];
-}
-export declare class ValidationBuilder {
-    string(message: string): StringValidator;
-    number(message: string): NumberValidator;
-    boolean(message: string): BooleanValidator;
-    date(message: string): DateValidator;
-    json(model: Record<string, FieldValidator>): JsonValidator;
-}
-export declare const f: () => ValidationBuilder;
-export {};

package/lib/cjs/orm/validation.js

@@ -1,128 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.f = exports.ValidationBuilder = exports.FieldValidator = void 0;
-class FieldValidator {
-    constructor() {
-        this._type = null;
-        this._cases = [];
-        this._default = undefined;
-    }
-    get type() {
-        return this._type;
-    }
-    get defaultValue() {
-        return this._default;
-    }
-    default(value) {
-        this._default = value;
-        return this;
-    }
-    when(test) {
-        this._cases.push(test);
-        return this;
-    }
-    validate(value, context) {
-        return this._cases.map((fn) => fn(value, context)).filter((res) => res !== null);
-    }
-}
-exports.FieldValidator = FieldValidator;
-class NumberValidator extends FieldValidator {
-    constructor(message) {
-        super();
-        this._type = 'number';
-        this._cases.push((value) => (value === null || value === undefined ? null : typeof value !== 'number' ? message : null));
-    }
-    required(message) {
-        this._cases.push((value) => (value === undefined || value === null || String(value).trim() === '' ? message : null));
-        return this;
-    }
-    min(min, message) {
-        this._cases.push((value) => (typeof value === 'number' && value < min ? message : null));
-        return this;
-    }
-    max(max, message) {
-        this._cases.push((value) => (typeof value === 'number' && value > max ? message : null));
-        return this;
-    }
-}
-class StringValidator extends FieldValidator {
-    constructor(message) {
-        super();
-        this._type = 'string';
-        this._cases.push((value) => (value === null || value === undefined ? null : typeof value !== 'string' ? message : null));
-    }
-    required(message) {
-        this._cases.push((value) => (!value || String(value).trim() === '' ? message : null));
-        return this;
-    }
-    match(regex, message) {
-        this._cases.push((value) => (value === null || value === undefined ? null : !regex.test(String(value)) ? message : null));
-        return this;
-    }
-}
-class BooleanValidator extends FieldValidator {
-    constructor(message) {
-        super();
-        this._type = 'boolean';
-        this._cases.push((value) => (value === null || value === undefined ? null : typeof value !== 'boolean' ? message : null));
-    }
-    required(message) {
-        this._cases.push((value) => (typeof value !== 'boolean' ? message : null));
-        return this;
-    }
-}
-class DateValidator extends FieldValidator {
-    constructor(message) {
-        super();
-        this._type = 'date';
-        this._cases.push((value) => {
-            if (value === null || value === undefined)
-                return null;
-            const d = new Date(value);
-            return isNaN(d.getTime()) ? message : null;
-        });
-    }
-    required(message) {
-        return this.when((value) => (!value ? message : null));
-    }
-}
-class JsonValidator extends FieldValidator {
-    constructor(children) {
-        super();
-        this.children = children;
-        this._type = 'jsonb';
-    }
-    validate(value, context) {
-        if (typeof value !== 'object' || value === null) {
-            return ['Must be a valid JSON object.'];
-        }
-        if (!this.children)
-            return [];
-        const errors = [];
-        for (const [key, validator] of Object.entries(this.children)) {
-            const childErrors = validator.validate(value[key], context);
-            errors.push(...childErrors.map((e) => `${key}: ${e}`));
-        }
-        return errors;
-    }
-}
-class ValidationBuilder {
-    string(message) {
-        return new StringValidator(message);
-    }
-    number(message) {
-        return new NumberValidator(message);
-    }
-    boolean(message) {
-        return new BooleanValidator(message);
-    }
-    date(message) {
-        return new DateValidator(message);
-    }
-    json(model) {
-        return new JsonValidator(model);
-    }
-}
-exports.ValidationBuilder = ValidationBuilder;
-const f = () => new ValidationBuilder();
-exports.f = f;

package/lib/cjs/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "commonjs"
-}

package/lib/cjs/persistent/cache/core-context.d.ts

@@ -1,17 +0,0 @@
-/**
- * Especialized storage for Opposer Core Context.
- * Uses GlobalStorage internally but provides a clean Singleton interface
- * for the server engine and public consumption.
- */
-declare class ContextStorage {
-    private static instance;
-    private readonly namespace;
-    private constructor();
-    static getInstance(): ContextStorage;
-    set<T>(key: string, value: T): void;
-    get<T>(key: string): T;
-    has(key: string): boolean;
-    clear(): void;
-}
-declare const _default: ContextStorage;
-export default _default;

package/lib/cjs/persistent/cache/core-context.js

@@ -1,39 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const global_js_1 = __importDefault(require("../cache/global.js"));
-/**
- * Especialized storage for Opposer Core Context.
- * Uses GlobalStorage internally but provides a clean Singleton interface
- * for the server engine and public consumption.
- */
-class ContextStorage {
-    constructor() {
-        this.namespace = "opposer:core:context";
-    }
-    static getInstance() {
-        if (!ContextStorage.instance) {
-            ContextStorage.instance = new ContextStorage();
-        }
-        return ContextStorage.instance;
-    }
-    set(key, value) {
-        const data = global_js_1.default.get(this.namespace) || {};
-        data[key] = value;
-        global_js_1.default.set(this.namespace, data);
-    }
-    get(key) {
-        const data = global_js_1.default.get(this.namespace) || {};
-        return data[key];
-    }
-    has(key) {
-        const data = global_js_1.default.get(this.namespace) || {};
-        return Object.prototype.hasOwnProperty.call(data, key);
-    }
-    clear() {
-        global_js_1.default.set(this.namespace, {});
-    }
-}
-exports.default = ContextStorage.getInstance();

package/lib/cjs/persistent/cache/global.d.ts

@@ -1,18 +0,0 @@
-import type { CacheSettings } from "../interfaces/system.js";
-import Store from "./store.js";
-declare const _default: {
-    __settings: CacheSettings;
-    __data: Store;
-    set(key: string, value: any): void;
-    get(key: string): any;
-    __isMaxSizeMemory: boolean;
-    __currentSizeMemory: number;
-    snapshot(): void;
-    restore(): void;
-    size(): boolean;
-    revalidate(): void | null;
-    notifyStoresForClearMemoryPerPolicy(): void;
-    clear(): void;
-    configure(): /*elided*/ any;
-};
-export default _default;

package/lib/cjs/persistent/cache/global.js

@@ -1,22 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_js_1 = __importDefault(require("../system/index.js"));
-const storage_js_1 = __importDefault(require("./storage.js"));
-const store_js_1 = __importDefault(require("./store.js"));
-exports.default = new (class Global extends storage_js_1.default {
-    constructor() {
-        super();
-        this.__settings = index_js_1.default.settings.cache.global;
-        this.__data = new store_js_1.default();
-        this.__data.setSettings(index_js_1.default.settings.cache.global);
-    }
-    set(key, value) {
-        this.__data.set(key, value);
-    }
-    get(key) {
-        return this.__data.get(key);
-    }
-})().configure();

package/lib/cjs/persistent/cache/index.d.ts

@@ -1,3 +0,0 @@
-export { default as SessionStorage } from "./session";
-export { default as GlobalStorage } from "./global";
-export { default as Store } from "./store";

package/lib/cjs/persistent/cache/index.js

@@ -1,12 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Store = exports.GlobalStorage = exports.SessionStorage = void 0;
-var session_1 = require("./session");
-Object.defineProperty(exports, "SessionStorage", { enumerable: true, get: function () { return __importDefault(session_1).default; } });
-var global_1 = require("./global");
-Object.defineProperty(exports, "GlobalStorage", { enumerable: true, get: function () { return __importDefault(global_1).default; } });
-var store_1 = require("./store");
-Object.defineProperty(exports, "Store", { enumerable: true, get: function () { return __importDefault(store_1).default; } });

package/lib/cjs/persistent/cache/session.d.ts

@@ -1,19 +0,0 @@
-import type { Request, Response, NextFunction } from "express";
-import Store from "./store.js";
-declare const _default: {
-    createStore(sessionId: string): Store;
-    loadStore(sessionId: string): Store | null;
-    initialize(req: Request, res: Response, next: NextFunction): Response<any, Record<string, any>> | undefined;
-    __settings: import("../interfaces/system.js").CacheSettings;
-    __data: Record<string, any>;
-    __isMaxSizeMemory: boolean;
-    __currentSizeMemory: number;
-    snapshot(): void;
-    restore(): void;
-    size(): boolean;
-    revalidate(): void | null;
-    notifyStoresForClearMemoryPerPolicy(): void;
-    clear(): void;
-    configure(): /*elided*/ any;
-};
-export default _default;

package/lib/cjs/persistent/cache/session.js

@@ -1,39 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_js_1 = __importDefault(require("../context/index.js"));
-const storage_js_1 = __importDefault(require("./storage.js"));
-const store_js_1 = __importDefault(require("./store.js"));
-exports.default = new (class Session extends storage_js_1.default {
-    createStore(sessionId) {
-        const store = new store_js_1.default(sessionId);
-        Object.defineProperty(this.__data, sessionId, {
-            value: store,
-            writable: true,
-            enumerable: true,
-            configurable: true,
-        });
-        return store;
-    }
-    loadStore(sessionId) {
-        const store = this.__data[sessionId];
-        if (!store) {
-            if (this.__isMaxSizeMemory) {
-                return null;
-            }
-            return this.createStore(sessionId);
-        }
-        store.revalidateTimer();
-        return store;
-    }
-    initialize(req, res, next) {
-        const sessionId = req.headers["session-opposer-id"];
-        const store = this.loadStore(sessionId);
-        if (!sessionId) {
-            return res.status(401);
-        }
-        index_js_1.default.run({ store, sessionId }, next);
-    }
-})().configure();