@wabot-dev/framework 0.1.0-beta.9 → 0.2.0-beta.1

package/dist/src/node_modules/selderee/lib/selderee.js

@@ -1,380 +0,0 @@
-import { parse1, normalize, compareSpecificity, serialize } from '../../parseley/lib/parseley.js';
-
-class DecisionTree {
-    constructor(input) {
-        this.branches = weave(toAstTerminalPairs(input));
-    }
-    build(builder) {
-        return builder(this.branches);
-    }
-}
-function toAstTerminalPairs(array) {
-    const len = array.length;
-    const results = new Array(len);
-    for (let i = 0; i < len; i++) {
-        const [selectorString, val] = array[i];
-        const ast = preprocess(parse1(selectorString));
-        results[i] = {
-            ast: ast,
-            terminal: {
-                type: 'terminal',
-                valueContainer: { index: i, value: val, specificity: ast.specificity }
-            }
-        };
-    }
-    return results;
-}
-function preprocess(ast) {
-    reduceSelectorVariants(ast);
-    normalize(ast);
-    return ast;
-}
-function reduceSelectorVariants(ast) {
-    const newList = [];
-    ast.list.forEach(sel => {
-        switch (sel.type) {
-            case 'class':
-                newList.push({
-                    matcher: '~=',
-                    modifier: null,
-                    name: 'class',
-                    namespace: null,
-                    specificity: sel.specificity,
-                    type: 'attrValue',
-                    value: sel.name,
-                });
-                break;
-            case 'id':
-                newList.push({
-                    matcher: '=',
-                    modifier: null,
-                    name: 'id',
-                    namespace: null,
-                    specificity: sel.specificity,
-                    type: 'attrValue',
-                    value: sel.name,
-                });
-                break;
-            case 'combinator':
-                reduceSelectorVariants(sel.left);
-                newList.push(sel);
-                break;
-            case 'universal':
-                break;
-            default:
-                newList.push(sel);
-                break;
-        }
-    });
-    ast.list = newList;
-}
-function weave(items) {
-    const branches = [];
-    while (items.length) {
-        const topKind = findTopKey(items, (sel) => true, getSelectorKind);
-        const { matches, nonmatches, empty } = breakByKind(items, topKind);
-        items = nonmatches;
-        if (matches.length) {
-            branches.push(branchOfKind(topKind, matches));
-        }
-        if (empty.length) {
-            branches.push(...terminate(empty));
-        }
-    }
-    return branches;
-}
-function terminate(items) {
-    const results = [];
-    for (const item of items) {
-        const terminal = item.terminal;
-        if (terminal.type === 'terminal') {
-            results.push(terminal);
-        }
-        else {
-            const { matches, rest } = partition(terminal.cont, (node) => node.type === 'terminal');
-            matches.forEach((node) => results.push(node));
-            if (rest.length) {
-                terminal.cont = rest;
-                results.push(terminal);
-            }
-        }
-    }
-    return results;
-}
-function breakByKind(items, selectedKind) {
-    const matches = [];
-    const nonmatches = [];
-    const empty = [];
-    for (const item of items) {
-        const simpsels = item.ast.list;
-        if (simpsels.length) {
-            const isMatch = simpsels.some(node => getSelectorKind(node) === selectedKind);
-            (isMatch ? matches : nonmatches).push(item);
-        }
-        else {
-            empty.push(item);
-        }
-    }
-    return { matches, nonmatches, empty };
-}
-function getSelectorKind(sel) {
-    switch (sel.type) {
-        case 'attrPresence':
-            return `attrPresence ${sel.name}`;
-        case 'attrValue':
-            return `attrValue ${sel.name}`;
-        case 'combinator':
-            return `combinator ${sel.combinator}`;
-        default:
-            return sel.type;
-    }
-}
-function branchOfKind(kind, items) {
-    if (kind === 'tag') {
-        return tagNameBranch(items);
-    }
-    if (kind.startsWith('attrValue ')) {
-        return attrValueBranch(kind.substring(10), items);
-    }
-    if (kind.startsWith('attrPresence ')) {
-        return attrPresenceBranch(kind.substring(13), items);
-    }
-    if (kind === 'combinator >') {
-        return combinatorBranch('>', items);
-    }
-    if (kind === 'combinator +') {
-        return combinatorBranch('+', items);
-    }
-    throw new Error(`Unsupported selector kind: ${kind}`);
-}
-function tagNameBranch(items) {
-    const groups = spliceAndGroup(items, (x) => x.type === 'tag', (x) => x.name);
-    const variants = Object.entries(groups).map(([name, group]) => ({
-        type: 'variant',
-        value: name,
-        cont: weave(group.items)
-    }));
-    return {
-        type: 'tagName',
-        variants: variants
-    };
-}
-function attrPresenceBranch(name, items) {
-    for (const item of items) {
-        spliceSimpleSelector(item, (x) => (x.type === 'attrPresence') && (x.name === name));
-    }
-    return {
-        type: 'attrPresence',
-        name: name,
-        cont: weave(items)
-    };
-}
-function attrValueBranch(name, items) {
-    const groups = spliceAndGroup(items, (x) => (x.type === 'attrValue') && (x.name === name), (x) => `${x.matcher} ${x.modifier || ''} ${x.value}`);
-    const matchers = [];
-    for (const group of Object.values(groups)) {
-        const sel = group.oneSimpleSelector;
-        const predicate = getAttrPredicate(sel);
-        const continuation = weave(group.items);
-        matchers.push({
-            type: 'matcher',
-            matcher: sel.matcher,
-            modifier: sel.modifier,
-            value: sel.value,
-            predicate: predicate,
-            cont: continuation
-        });
-    }
-    return {
-        type: 'attrValue',
-        name: name,
-        matchers: matchers
-    };
-}
-function getAttrPredicate(sel) {
-    if (sel.modifier === 'i') {
-        const expected = sel.value.toLowerCase();
-        switch (sel.matcher) {
-            case '=':
-                return (actual) => expected === actual.toLowerCase();
-            case '~=':
-                return (actual) => actual.toLowerCase().split(/[ \t]+/).includes(expected);
-            case '^=':
-                return (actual) => actual.toLowerCase().startsWith(expected);
-            case '$=':
-                return (actual) => actual.toLowerCase().endsWith(expected);
-            case '*=':
-                return (actual) => actual.toLowerCase().includes(expected);
-            case '|=':
-                return (actual) => {
-                    const lower = actual.toLowerCase();
-                    return (expected === lower) || (lower.startsWith(expected) && lower[expected.length] === '-');
-                };
-        }
-    }
-    else {
-        const expected = sel.value;
-        switch (sel.matcher) {
-            case '=':
-                return (actual) => expected === actual;
-            case '~=':
-                return (actual) => actual.split(/[ \t]+/).includes(expected);
-            case '^=':
-                return (actual) => actual.startsWith(expected);
-            case '$=':
-                return (actual) => actual.endsWith(expected);
-            case '*=':
-                return (actual) => actual.includes(expected);
-            case '|=':
-                return (actual) => (expected === actual) || (actual.startsWith(expected) && actual[expected.length] === '-');
-        }
-    }
-}
-function combinatorBranch(combinator, items) {
-    const groups = spliceAndGroup(items, (x) => (x.type === 'combinator') && (x.combinator === combinator), (x) => serialize(x.left));
-    const leftItems = [];
-    for (const group of Object.values(groups)) {
-        const rightCont = weave(group.items);
-        const leftAst = group.oneSimpleSelector.left;
-        leftItems.push({
-            ast: leftAst,
-            terminal: { type: 'popElement', cont: rightCont }
-        });
-    }
-    return {
-        type: 'pushElement',
-        combinator: combinator,
-        cont: weave(leftItems)
-    };
-}
-function spliceAndGroup(items, predicate, keyCallback) {
-    const groups = {};
-    while (items.length) {
-        const bestKey = findTopKey(items, predicate, keyCallback);
-        const bestKeyPredicate = (sel) => predicate(sel) && keyCallback(sel) === bestKey;
-        const hasBestKeyPredicate = (item) => item.ast.list.some(bestKeyPredicate);
-        const { matches, rest } = partition1(items, hasBestKeyPredicate);
-        let oneSimpleSelector = null;
-        for (const item of matches) {
-            const splicedNode = spliceSimpleSelector(item, bestKeyPredicate);
-            if (!oneSimpleSelector) {
-                oneSimpleSelector = splicedNode;
-            }
-        }
-        if (oneSimpleSelector == null) {
-            throw new Error('No simple selector is found.');
-        }
-        groups[bestKey] = { oneSimpleSelector: oneSimpleSelector, items: matches };
-        items = rest;
-    }
-    return groups;
-}
-function spliceSimpleSelector(item, predicate) {
-    const simpsels = item.ast.list;
-    const matches = new Array(simpsels.length);
-    let firstIndex = -1;
-    for (let i = simpsels.length; i-- > 0;) {
-        if (predicate(simpsels[i])) {
-            matches[i] = true;
-            firstIndex = i;
-        }
-    }
-    if (firstIndex == -1) {
-        throw new Error(`Couldn't find the required simple selector.`);
-    }
-    const result = simpsels[firstIndex];
-    item.ast.list = simpsels.filter((sel, i) => !matches[i]);
-    return result;
-}
-function findTopKey(items, predicate, keyCallback) {
-    const candidates = {};
-    for (const item of items) {
-        const candidates1 = {};
-        for (const node of item.ast.list.filter(predicate)) {
-            candidates1[keyCallback(node)] = true;
-        }
-        for (const key of Object.keys(candidates1)) {
-            if (candidates[key]) {
-                candidates[key]++;
-            }
-            else {
-                candidates[key] = 1;
-            }
-        }
-    }
-    let topKind = '';
-    let topCounter = 0;
-    for (const entry of Object.entries(candidates)) {
-        if (entry[1] > topCounter) {
-            topKind = entry[0];
-            topCounter = entry[1];
-        }
-    }
-    return topKind;
-}
-function partition(src, predicate) {
-    const matches = [];
-    const rest = [];
-    for (const x of src) {
-        if (predicate(x)) {
-            matches.push(x);
-        }
-        else {
-            rest.push(x);
-        }
-    }
-    return { matches, rest };
-}
-function partition1(src, predicate) {
-    const matches = [];
-    const rest = [];
-    for (const x of src) {
-        if (predicate(x)) {
-            matches.push(x);
-        }
-        else {
-            rest.push(x);
-        }
-    }
-    return { matches, rest };
-}
-
-class Picker {
-    constructor(f) {
-        this.f = f;
-    }
-    pickAll(el) {
-        return this.f(el);
-    }
-    pick1(el, preferFirst = false) {
-        const results = this.f(el);
-        const len = results.length;
-        if (len === 0) {
-            return null;
-        }
-        if (len === 1) {
-            return results[0].value;
-        }
-        const comparator = (preferFirst)
-            ? comparatorPreferFirst
-            : comparatorPreferLast;
-        let result = results[0];
-        for (let i = 1; i < len; i++) {
-            const next = results[i];
-            if (comparator(result, next)) {
-                result = next;
-            }
-        }
-        return result.value;
-    }
-}
-function comparatorPreferFirst(acc, next) {
-    const diff = compareSpecificity(next.specificity, acc.specificity);
-    return diff > 0 || (diff === 0 && next.index < acc.index);
-}
-function comparatorPreferLast(acc, next) {
-    const diff = compareSpecificity(next.specificity, acc.specificity);
-    return diff > 0 || (diff === 0 && next.index > acc.index);
-}
-
-export { DecisionTree, Picker };

package/dist/src/pre-made/module/authentication/AuthenticationModule.js

@@ -1,97 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import '../../../core/chat/repository/IChatRepository.js';
-import { UserRepository } from '../../../core/user/IUserRepository.js';
-import { MessageContext } from '../../../core/IMessageContext.js';
-import { mindsetFunction } from '../../../mindset/metadata/functions/@mindsetFunction.js';
-import 'reflect-metadata';
-import '../../../injection/index.js';
-import '../../../mindset/metadata/MindsetMetadataStore.js';
-import { mindsetModule } from '../../../mindset/metadata/modules/@mindsetModule.js';
-import '../../../mindset/MindsetOperator.js';
-import { EmailService } from '../../service/EmailService.js';
-import { OtpService } from '../../service/OtpService.js';
-import { SendOneTimePasswordRequest } from './requests/SendOneTimePasswordRequest.js';
-import { ValidateOneTimePasswordRequest } from './requests/ValidateOneTimePasswordRequest.js';
-
-let AuthenticationModule = class AuthenticationModule {
-    userRepository;
-    emailService;
-    otpService;
-    context;
-    constructor(userRepository, emailService, otpService, context) {
-        this.userRepository = userRepository;
-        this.emailService = emailService;
-        this.otpService = otpService;
-        this.context = context;
-    }
-    async sendOneTimePassword(request) {
-        const user = await this.userRepository.findByConnection({
-            channelName: 'EmailChannel',
-            id: request.toEmail,
-        });
-        if (!user)
-            return 'success';
-        const otp = await this.otpService.generate();
-        const html = await this.generateOtpEmailHtml(otp, user);
-        const subject = await this.generateOtpEmailSubject();
-        await this.emailService.sendEmail({
-            from: request.fromEmail,
-            to: request.toEmail,
-            subject,
-            html,
-        });
-        user.setValue('OTP', otp);
-        await this.userRepository.update(user);
-        return 'success';
-    }
-    async validateOneTimePassword(request) {
-        const user = await this.userRepository.findByConnection({
-            channelName: 'EmailChannel',
-            id: request.userEmail,
-        });
-        if (!user) {
-            throw new Error('Invalid OTP');
-        }
-        const otp = user.getValue('OTP');
-        if (otp !== request.otp) {
-            throw new Error('Invalid OTP');
-        }
-        user.addConnection(this.context.message.userConnection);
-        await this.userRepository.update(user);
-        return 'success';
-    }
-    async generateOtpEmailHtml(otp, user) {
-        return `<p>Your OTP Code is ${otp}</p>`;
-    }
-    async generateOtpEmailSubject() {
-        return 'OTP Code';
-    }
-};
-__decorate([
-    mindsetFunction({
-        description: 'Send an One Time Password to the user when want authenticate',
-    }),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [SendOneTimePasswordRequest]),
-    __metadata("design:returntype", Promise)
-], AuthenticationModule.prototype, "sendOneTimePassword", null);
-__decorate([
-    mindsetFunction({
-        description: 'Send an One Time Password to the user when want authenticate',
-    }),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [ValidateOneTimePasswordRequest]),
-    __metadata("design:returntype", Promise)
-], AuthenticationModule.prototype, "validateOneTimePassword", null);
-AuthenticationModule = __decorate([
-    mindsetModule({
-        description: 'Provide authentication methods',
-        language: 'english',
-    }),
-    __metadata("design:paramtypes", [UserRepository,
-        EmailService,
-        OtpService,
-        MessageContext])
-], AuthenticationModule);
-
-export { AuthenticationModule };

package/dist/src/pre-made/module/authentication/requests/SendOneTimePasswordRequest.js

@@ -1,25 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import 'reflect-metadata';
-import '../../../../injection/index.js';
-import '../../../../mindset/metadata/MindsetMetadataStore.js';
-import { param } from '../../../../mindset/metadata/params/@param.js';
-import '../../../../mindset/MindsetOperator.js';
-
-class SendOneTimePasswordRequest {
-    fromEmail = '';
-    toEmail = '';
-}
-__decorate([
-    param({
-        description: 'Sender Email address',
-    }),
-    __metadata("design:type", String)
-], SendOneTimePasswordRequest.prototype, "fromEmail", void 0);
-__decorate([
-    param({
-        description: 'Recipient Email Address, to send one time password',
-    }),
-    __metadata("design:type", String)
-], SendOneTimePasswordRequest.prototype, "toEmail", void 0);
-
-export { SendOneTimePasswordRequest };

package/dist/src/pre-made/module/authentication/requests/ValidateOneTimePasswordRequest.js

@@ -1,25 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import 'reflect-metadata';
-import '../../../../injection/index.js';
-import '../../../../mindset/metadata/MindsetMetadataStore.js';
-import { param } from '../../../../mindset/metadata/params/@param.js';
-import '../../../../mindset/MindsetOperator.js';
-
-class ValidateOneTimePasswordRequest {
-    userEmail = '';
-    otp = '';
-}
-__decorate([
-    param({
-        description: 'User Email',
-    }),
-    __metadata("design:type", String)
-], ValidateOneTimePasswordRequest.prototype, "userEmail", void 0);
-__decorate([
-    param({
-        description: 'Otp provided by the User',
-    }),
-    __metadata("design:type", String)
-], ValidateOneTimePasswordRequest.prototype, "otp", void 0);
-
-export { ValidateOneTimePasswordRequest };

package/dist/src/pre-made/module/register-user/RegisterUserModule.js

@@ -1,56 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import '../../../core/chat/repository/IChatRepository.js';
-import { User } from '../../../core/user/User.js';
-import { UserRepository } from '../../../core/user/IUserRepository.js';
-import { MessageContext } from '../../../core/IMessageContext.js';
-import { mindsetFunction } from '../../../mindset/metadata/functions/@mindsetFunction.js';
-import 'reflect-metadata';
-import '../../../injection/index.js';
-import '../../../mindset/metadata/MindsetMetadataStore.js';
-import { mindsetModule } from '../../../mindset/metadata/modules/@mindsetModule.js';
-import '../../../mindset/MindsetOperator.js';
-import { RegisterUserWithEmailRequest } from './requests/RegisterUserWithEmailRequest.js';
-
-let RegisterUserModule = class RegisterUserModule {
-    userRepository;
-    context;
-    constructor(userRepository, context) {
-        this.userRepository = userRepository;
-        this.context = context;
-    }
-    async registerUserWithEmail(request) {
-        if (this.context.user) {
-            throw new Error('The User is already authenticated');
-        }
-        const user = new User({
-            shortName: request.shortName,
-            connections: [
-                {
-                    channelName: 'EmailChannel',
-                    id: request.email,
-                },
-            ],
-            keyValueData: {},
-        });
-        await this.userRepository.create(user);
-        return 'success';
-    }
-};
-__decorate([
-    mindsetFunction({
-        description: 'Register a new user using email',
-    }),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [RegisterUserWithEmailRequest]),
-    __metadata("design:returntype", Promise)
-], RegisterUserModule.prototype, "registerUserWithEmail", null);
-RegisterUserModule = __decorate([
-    mindsetModule({
-        description: 'Provide functions to register an user',
-        language: 'english',
-    }),
-    __metadata("design:paramtypes", [UserRepository,
-        MessageContext])
-], RegisterUserModule);
-
-export { RegisterUserModule };

package/dist/src/pre-made/module/register-user/requests/RegisterUserWithEmailRequest.js

@@ -1,25 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import 'reflect-metadata';
-import '../../../../injection/index.js';
-import '../../../../mindset/metadata/MindsetMetadataStore.js';
-import { param } from '../../../../mindset/metadata/params/@param.js';
-import '../../../../mindset/MindsetOperator.js';
-
-class RegisterUserWithEmailRequest {
-    email = '';
-    shortName = '';
-}
-__decorate([
-    param({
-        description: 'Email of the User',
-    }),
-    __metadata("design:type", String)
-], RegisterUserWithEmailRequest.prototype, "email", void 0);
-__decorate([
-    param({
-        description: 'ShortName for the new User',
-    }),
-    __metadata("design:type", String)
-], RegisterUserWithEmailRequest.prototype, "shortName", void 0);
-
-export { RegisterUserWithEmailRequest };

package/dist/src/pre-made/repository/user/pg/PgUserRepository.js

@@ -1,33 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import '../../../../core/chat/repository/IChatRepository.js';
-import { User } from '../../../../core/user/User.js';
-import '../../../../core/user/IUserRepository.js';
-import { singleton } from '../../../../injection/index.js';
-import { PgCrudRepository } from '../../../../repository/pg/PgCrudRepository.js';
-import { Pool } from 'pg';
-
-let PgUserRepository = class PgUserRepository extends PgCrudRepository {
-    constructor(pool) {
-        super(pool, {
-            table: 'user',
-            schema: 'wabot',
-            constructor: User,
-        });
-    }
-    async findByConnection(query) {
-        const sql = `
-      SELECT ${this.columns}
-      FROM ${this.table}
-      WHERE data->'connections' @> $1::jsonb
-      LIMIT 1
-    `;
-        const items = await this.query(sql, [JSON.stringify([query])]);
-        return items.at(0) ?? null;
-    }
-};
-PgUserRepository = __decorate([
-    singleton(),
-    __metadata("design:paramtypes", [Pool])
-], PgUserRepository);
-
-export { PgUserRepository };

package/dist/src/pre-made/repository/user/ram/RamUserRepository.js

@@ -1,27 +0,0 @@
-import { __decorate } from 'tslib';
-import { v4 } from 'uuid';
-import { singleton } from '../../../../injection/index.js';
-
-let RamUserRepository = class RamUserRepository {
-    items = [];
-    async create(chat) {
-        if (chat.wasCreated()) {
-            throw new Error('User already created');
-        }
-        chat['data'].id = v4();
-        chat['data'].createdAt = new Date().getTime();
-        chat.validate();
-        this.items.push(chat);
-    }
-    async findByConnection(query) {
-        return this.items.find((item) => item.hasConnection(query)) ?? null;
-    }
-    async update(chat) {
-        // TODO
-    }
-};
-RamUserRepository = __decorate([
-    singleton()
-], RamUserRepository);
-
-export { RamUserRepository };

package/dist/src/pre-made/service/EmailService.js

@@ -1,13 +0,0 @@
-import { __decorate } from 'tslib';
-import { injectable } from '../../injection/index.js';
-
-let EmailService = class EmailService {
-    async sendEmail(request) {
-        throw new Error('Not implemented');
-    }
-};
-EmailService = __decorate([
-    injectable()
-], EmailService);
-
-export { EmailService };