@abtnode/models 1.16.8-next-d1e52353

package/lib/models/server.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServerModel = void 0;
+const sequelize_1 = require("sequelize");
+function createServerModel() {
+    var _a;
+    return _a = class Server extends sequelize_1.Model {
+            static initialize(sequelize) {
+                this.init({
+                    ...this.GENESIS_ATTRIBUTES,
+                }, {
+                    sequelize,
+                    modelName: 'Server',
+                    tableName: 'servers',
+                    timestamps: true,
+                });
+            }
+        },
+        // CAUTION: do not edit this
+        _a.GENESIS_ATTRIBUTES = {
+            did: {
+                type: sequelize_1.DataTypes.STRING(40),
+                primaryKey: true,
+                unique: true,
+            },
+            autoUpgrade: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+            },
+            blockletRegistryList: {
+                type: sequelize_1.DataTypes.JSON,
+            },
+            registerUrl: {
+                type: sequelize_1.DataTypes.STRING(255),
+            },
+            webWalletUrl: {
+                type: sequelize_1.DataTypes.STRING(255),
+            },
+            name: {
+                type: sequelize_1.DataTypes.STRING(64),
+            },
+            description: {
+                type: sequelize_1.DataTypes.STRING(255),
+            },
+            pk: {
+                type: sequelize_1.DataTypes.STRING(255),
+            },
+            sk: {
+                type: sequelize_1.DataTypes.STRING(512),
+            },
+            initialized: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+            },
+            version: {
+                type: sequelize_1.DataTypes.STRING(32),
+            },
+            port: {
+                type: sequelize_1.DataTypes.INTEGER,
+            },
+            routing: {
+                type: sequelize_1.DataTypes.JSON,
+            },
+            mode: {
+                type: sequelize_1.DataTypes.STRING(32),
+            },
+            enableWelcomePage: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+            },
+            runtimeConfig: {
+                type: sequelize_1.DataTypes.JSON,
+            },
+            ownerNft: {
+                type: sequelize_1.DataTypes.JSON,
+            },
+            diskAlertThreshold: {
+                type: sequelize_1.DataTypes.INTEGER,
+            },
+            didRegistry: {
+                type: sequelize_1.DataTypes.STRING(255),
+            },
+            didDomain: {
+                type: sequelize_1.DataTypes.STRING(255),
+            },
+            enablePassportIssuance: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+            },
+            trustedPassports: {
+                type: sequelize_1.DataTypes.JSON,
+            },
+            trustedFactories: {
+                type: sequelize_1.DataTypes.JSON,
+            },
+            customBlockletNumber: {
+                type: sequelize_1.DataTypes.INTEGER,
+            },
+            createdAt: {
+                type: sequelize_1.DataTypes.DATE,
+                defaultValue: sequelize_1.DataTypes.NOW,
+            },
+            updatedAt: {
+                type: sequelize_1.DataTypes.DATE,
+                defaultValue: sequelize_1.DataTypes.NOW,
+            },
+            nodeOwner: {
+                type: sequelize_1.DataTypes.JSON,
+            },
+            startedAt: {
+                type: sequelize_1.DataTypes.DATE,
+            },
+            initializedAt: {
+                type: sequelize_1.DataTypes.DATE,
+            },
+            nextVersion: {
+                type: sequelize_1.DataTypes.STRING(32),
+            },
+            previousMode: {
+                type: sequelize_1.DataTypes.STRING(32),
+            },
+            status: {
+                type: sequelize_1.DataTypes.INTEGER,
+            },
+            enableBetaRelease: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+            },
+            upgradeSessionId: {
+                type: sequelize_1.DataTypes.STRING(32),
+            },
+        },
+        _a;
+}
+exports.createServerModel = createServerModel;

package/lib/models/session.d.ts

@@ -0,0 +1,10 @@
+import { DynamicModel } from '../types';
+export type SessionState = {
+    id: string;
+    type: string;
+    key: string;
+    __data: any;
+    createdAt: Date;
+    updatedAt: Date;
+};
+export declare function createSessionModel(): DynamicModel<SessionState>;

package/lib/models/session.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSessionModel = void 0;
+// Storage for multi-step conversations or long running tasks
+const sequelize_1 = require("sequelize");
+const util_1 = require("../util");
+function createSessionModel() {
+    var _a;
+    return _a = class Session extends sequelize_1.Model {
+            static initialize(sequelize) {
+                this.init({
+                    ...this.GENESIS_ATTRIBUTES,
+                }, {
+                    sequelize,
+                    indexes: [{ fields: ['type', 'id'] }],
+                    modelName: 'Session',
+                    tableName: 'sessions',
+                    timestamps: true,
+                });
+            }
+        },
+        _a.GENESIS_ATTRIBUTES = {
+            id: {
+                type: sequelize_1.DataTypes.STRING(40),
+                primaryKey: true,
+                allowNull: false,
+                defaultValue: util_1.generateId,
+            },
+            type: {
+                type: sequelize_1.DataTypes.STRING(64),
+                index: true,
+                allowNull: true,
+            },
+            key: {
+                type: sequelize_1.DataTypes.STRING(64),
+                index: true,
+            },
+            __data: {
+                type: sequelize_1.DataTypes.JSON,
+                allowNull: false,
+                defaultValue: {},
+            },
+            createdAt: {
+                type: sequelize_1.DataTypes.DATE,
+                defaultValue: sequelize_1.DataTypes.NOW,
+            },
+            updatedAt: {
+                type: sequelize_1.DataTypes.DATE,
+                defaultValue: sequelize_1.DataTypes.NOW,
+            },
+        },
+        _a;
+}
+exports.createSessionModel = createSessionModel;

package/lib/models/site.d.ts

@@ -0,0 +1,8 @@
+import { TRoutingSite } from '@abtnode/types';
+import { DynamicModel } from '../types';
+export type SiteState = TRoutingSite & {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+};
+export declare function createSiteModel(): DynamicModel<SiteState>;

package/lib/models/site.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSiteModel = void 0;
+const sequelize_1 = require("sequelize");
+const util_1 = require("../util");
+function createSiteModel() {
+    var _a;
+    return _a = class Site extends sequelize_1.Model {
+            static initialize(sequelize) {
+                this.init({
+                    ...this.GENESIS_ATTRIBUTES,
+                }, {
+                    sequelize,
+                    modelName: 'Site',
+                    tableName: 'sites',
+                    timestamps: true,
+                });
+            }
+        },
+        _a.GENESIS_ATTRIBUTES = {
+            id: {
+                type: sequelize_1.DataTypes.STRING(40),
+                primaryKey: true,
+                defaultValue: util_1.generateId,
+            },
+            domain: {
+                type: sequelize_1.DataTypes.STRING(255),
+                unique: true,
+            },
+            domainAliases: {
+                type: sequelize_1.DataTypes.JSON,
+                defaultValue: [],
+            },
+            name: {
+                type: sequelize_1.DataTypes.STRING(32),
+            },
+            isProtected: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+                defaultValue: false,
+            },
+            rules: {
+                type: sequelize_1.DataTypes.JSON,
+                defaultValue: [],
+            },
+            createdAt: {
+                type: sequelize_1.DataTypes.DATE,
+                defaultValue: sequelize_1.DataTypes.NOW,
+                index: true,
+            },
+            updatedAt: {
+                type: sequelize_1.DataTypes.DATE,
+                defaultValue: sequelize_1.DataTypes.NOW,
+                index: true,
+            },
+            corsAllowedOrigins: {
+                type: sequelize_1.DataTypes.JSON,
+                defaultValue: [],
+            },
+        },
+        _a;
+}
+exports.createSiteModel = createSiteModel;

package/lib/models/user.d.ts

@@ -0,0 +1,6 @@
+import { TUserInfo } from '@abtnode/types';
+import { DynamicModel } from '../types';
+export type UserState = Omit<TUserInfo, 'passports' | 'connectedAccounts'> & {
+    extra: Record<string, any>;
+};
+export declare function createUserModel(): DynamicModel<UserState>;

package/lib/models/user.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUserModel = void 0;
+const sequelize_1 = require("sequelize");
+function createUserModel() {
+    var _a;
+    return _a = class User extends sequelize_1.Model {
+            static initialize(sequelize) {
+                this.init({
+                    ...this.GENESIS_ATTRIBUTES,
+                }, {
+                    sequelize,
+                    modelName: 'User',
+                    tableName: 'users',
+                    timestamps: true,
+                    indexes: [{ fields: ['email'] }, { fields: ['fullName'] }],
+                });
+            }
+            static associate(models) {
+                User.hasMany(models.Passport, {
+                    foreignKey: 'userDid',
+                    onDelete: 'CASCADE',
+                    as: 'passports',
+                });
+                User.hasMany(models.ConnectedAccount, {
+                    foreignKey: 'userDid',
+                    onDelete: 'CASCADE',
+                    as: 'connectedAccounts',
+                });
+            }
+        },
+        _a.GENESIS_ATTRIBUTES = {
+            did: {
+                type: sequelize_1.DataTypes.STRING(40),
+                primaryKey: true,
+                unique: true,
+            },
+            pk: {
+                type: sequelize_1.DataTypes.STRING(256),
+                allowNull: false,
+            },
+            fullName: {
+                type: sequelize_1.DataTypes.STRING(128),
+            },
+            email: {
+                type: sequelize_1.DataTypes.STRING(128),
+            },
+            avatar: {
+                // FIXME: make this a shorter string?
+                type: sequelize_1.DataTypes.TEXT,
+            },
+            role: {
+                type: sequelize_1.DataTypes.STRING(64),
+            },
+            remark: {
+                type: sequelize_1.DataTypes.STRING(128),
+                defaultValue: '',
+            },
+            sourceProvider: {
+                type: sequelize_1.DataTypes.STRING(32),
+            },
+            locale: {
+                type: sequelize_1.DataTypes.STRING(8),
+                defaultValue: 'en',
+            },
+            approved: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+                index: true,
+                defaultValue: true,
+            },
+            // server extended
+            extra: {
+                type: sequelize_1.DataTypes.JSON,
+                defaultValue: {},
+            },
+            // app extended
+            meta: {
+                type: sequelize_1.DataTypes.JSON,
+                defaultValue: {},
+            },
+            firstLoginAt: {
+                type: sequelize_1.DataTypes.DATE,
+                index: true,
+            },
+            lastLoginAt: {
+                type: sequelize_1.DataTypes.DATE,
+                index: true,
+            },
+            lastLoginIp: {
+                type: sequelize_1.DataTypes.STRING,
+            },
+            createdAt: {
+                type: sequelize_1.DataTypes.DATE,
+                defaultValue: sequelize_1.DataTypes.NOW,
+                index: true,
+            },
+            updatedAt: {
+                type: sequelize_1.DataTypes.DATE,
+                defaultValue: sequelize_1.DataTypes.NOW,
+                index: true,
+            },
+        },
+        _a;
+}
+exports.createUserModel = createUserModel;

package/lib/models/webhook.d.ts

@@ -0,0 +1,6 @@
+import { TWebHook } from '@abtnode/types';
+import { DynamicModel } from '../types';
+export type WebHookState = TWebHook & {
+    id: string;
+};
+export declare function createWebHookModel(): DynamicModel<WebHookState>;

package/lib/models/webhook.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWebHookModel = void 0;
+const sequelize_1 = require("sequelize");
+const util_1 = require("../util");
+function createWebHookModel() {
+    var _a;
+    return _a = class WebHook extends sequelize_1.Model {
+            static initialize(sequelize) {
+                this.init({
+                    ...this.GENESIS_ATTRIBUTES,
+                }, {
+                    sequelize,
+                    modelName: 'WebHook',
+                    tableName: 'webhooks',
+                    timestamps: true,
+                });
+            }
+        },
+        _a.GENESIS_ATTRIBUTES = {
+            id: {
+                type: sequelize_1.DataTypes.STRING(40),
+                primaryKey: true,
+                defaultValue: util_1.generateId,
+            },
+            type: {
+                type: sequelize_1.DataTypes.STRING(16),
+                allowNull: false,
+            },
+            params: {
+                type: sequelize_1.DataTypes.JSON,
+                allowNull: false,
+            },
+            createdAt: {
+                type: sequelize_1.DataTypes.DATE,
+                defaultValue: sequelize_1.DataTypes.NOW,
+                index: true,
+            },
+            updatedAt: {
+                type: sequelize_1.DataTypes.DATE,
+                defaultValue: sequelize_1.DataTypes.NOW,
+                index: true,
+            },
+        },
+        _a;
+}
+exports.createWebHookModel = createWebHookModel;

package/lib/states/base.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import { ModelDefined } from 'sequelize';
+import { AnyObject, SelectOptions, SortOptions, UpdateOptions, ConditionOptions, PagingOptions } from '../types';
+export declare class BaseState<T> extends EventEmitter {
+    model: ModelDefined<T, T>;
+    jsonAttributes: string[];
+    config: AnyObject;
+    ready: boolean;
+    readyCallbacks: Function[];
+    constructor(model: ModelDefined<T, T>, config?: AnyObject);
+    find(condition?: ConditionOptions<T>, selection?: SelectOptions<T>, sort?: SortOptions<T>): Promise<T[]>;
+    findOne(condition?: ConditionOptions<T>, selection?: SelectOptions<T>, sort?: SortOptions<T>): Promise<T>;
+    count(condition?: ConditionOptions<T>): Promise<number>;
+    insert(doc: any): Promise<T>;
+    insertMany(docs: any[]): Promise<T[]>;
+    update(condition: string | ConditionOptions<T>, updates: AnyObject, options?: UpdateOptions): Promise<[number, T[]]>;
+    updateById(id: string, updates: AnyObject, options?: UpdateOptions): Promise<[number, T[]]>;
+    upsert(condition: ConditionOptions<T>, updates: AnyObject): Promise<T>;
+    paginate(condition: ConditionOptions<T>, sort: SortOptions<T>, paging: PagingOptions, selection?: SelectOptions<T>): Promise<{
+        list: T[];
+        paging: {
+            total: number;
+            pageSize: number;
+            pageCount: number;
+            page: number;
+        };
+    }>;
+    remove(condition: ConditionOptions<T>): Promise<number>;
+    max(field: keyof T, condition?: ConditionOptions<T>): Promise<unknown>;
+    min(field: keyof T, condition?: ConditionOptions<T>): Promise<unknown>;
+    sum(field: keyof T, condition?: ConditionOptions<T>): Promise<number>;
+    query(query: string): Promise<object[]>;
+    reset(): Promise<number>;
+    loadDatabase(cb?: Function): void;
+    closeDatabase(cb?: Function): void;
+    compactDatafile(cb?: Function): void;
+    onReady(cb: Function): void;
+    static renameIdFiledName(docs: any): any;
+}

package/lib/states/base.js

@@ -0,0 +1,144 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseState = void 0;
+const events_1 = __importDefault(require("events"));
+const sequelize_1 = require("sequelize");
+const lodash_clonedeep_1 = __importDefault(require("lodash.clonedeep"));
+const util_1 = require("../util");
+class BaseState extends events_1.default {
+    constructor(model, config = {}) {
+        super();
+        this.model = model;
+        this.config = Object.freeze((0, lodash_clonedeep_1.default)(config));
+        // Just used to minic ready callbacks of @abtnode/db
+        this.ready = false;
+        this.readyCallbacks = [];
+        setImmediate(() => {
+            this.ready = true;
+            if (this.readyCallbacks.length) {
+                this.readyCallbacks.forEach((x) => x());
+            }
+        });
+    }
+    async find(condition = {}, selection = {}, sort = {}) {
+        const params = (0, util_1.formatParams)({
+            attributes: (0, util_1.formatSelection)(selection),
+            order: (0, util_1.formatOrder)(sort),
+            ...(0, util_1.formatConditions)(condition),
+            nest: true,
+        });
+        return this.model.findAll(params).then((x) => x.map((y) => y.toJSON()));
+    }
+    async findOne(condition = {}, selection = {}, sort = {}) {
+        const params = (0, util_1.formatParams)({
+            attributes: (0, util_1.formatSelection)(selection),
+            order: (0, util_1.formatOrder)(sort),
+            ...(0, util_1.formatConditions)(condition),
+        });
+        return this.model.findOne(params).then((x) => x?.toJSON());
+    }
+    async count(condition = {}) {
+        return this.model.count({ ...(0, util_1.formatConditions)(condition) });
+    }
+    async insert(doc) {
+        const newDoc = await this.model.create(doc, { returning: true });
+        await newDoc.save();
+        return newDoc.toJSON();
+    }
+    async insertMany(docs) {
+        const newDocs = await this.model.bulkCreate(docs, { returning: true });
+        return newDocs.map((x) => x.toJSON());
+    }
+    async update(condition, updates, options = {}) {
+        if (arguments.length < 2) {
+            throw new Error('condition and update param are required to update database record');
+        }
+        if (typeof condition === 'string') {
+            return this.updateById(condition, updates, options);
+        }
+        const [affectedRows] = await this.model.update(updates.$set || updates, {
+            where: (0, util_1.formatConditions)(condition).where,
+        });
+        const docs = options.returnUpdatedDocs ? await this.find(condition) : [];
+        return [affectedRows, docs];
+    }
+    async updateById(id, updates, options = {}) {
+        return this.update({ id }, updates, options);
+    }
+    async upsert(condition, updates) {
+        const [instance] = await this.model.upsert(Object.assign({}, condition, updates.$set || updates));
+        return instance.toJSON();
+    }
+    async paginate(condition, sort, paging, selection = {}) {
+        const { pageSize: size = 20, page = 1 } = paging || {};
+        const pageSize = Math.min(100, size);
+        const params = (0, util_1.formatParams)({
+            attributes: (0, util_1.formatSelection)(selection),
+            order: (0, util_1.formatOrder)(sort),
+            limit: pageSize,
+            offset: (page - 1) * pageSize,
+            ...(0, util_1.formatConditions)(condition),
+            nest: true,
+        });
+        const [count, rows] = await Promise.all([
+            this.model.count({ distinct: true, where: params.where }),
+            this.model.findAll(params),
+        ]);
+        return {
+            list: rows.map((x) => x.toJSON()),
+            paging: {
+                total: count,
+                pageSize,
+                pageCount: Math.ceil(count / pageSize),
+                page,
+            },
+        };
+    }
+    remove(condition) {
+        return this.model.destroy((0, util_1.formatConditions)(condition));
+    }
+    max(field, condition = {}) {
+        return this.model.max(field, (0, util_1.formatConditions)(condition));
+    }
+    min(field, condition = {}) {
+        return this.model.min(field, (0, util_1.formatConditions)(condition));
+    }
+    sum(field, condition = {}) {
+        return this.model.sum(field, (0, util_1.formatConditions)(condition));
+    }
+    query(query) {
+        return this.model.sequelize.query(query, { type: sequelize_1.QueryTypes.SELECT });
+    }
+    reset() {
+        return this.model.destroy({ truncate: true });
+    }
+    loadDatabase(cb) {
+        if (typeof cb === 'function') {
+            setImmediate(() => cb());
+        }
+    }
+    closeDatabase(cb = () => { }) {
+        // @ts-ignore
+        this.model.sequelize.close().then(cb).catch(cb);
+    }
+    compactDatafile(cb) {
+        if (typeof cb === 'function') {
+            setImmediate(() => cb());
+        }
+    }
+    onReady(cb) {
+        if (this.ready) {
+            cb();
+        }
+        else {
+            this.readyCallbacks.push(cb);
+        }
+    }
+    static renameIdFiledName(docs) {
+        return docs;
+    }
+}
+exports.BaseState = BaseState;

package/lib/states/factory.d.ts

@@ -0,0 +1 @@
+export declare function createStateFactory(initializer: Function, models: any): any;

package/lib/states/factory.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStateFactory = void 0;
+function createStateFactory(initializer, models) {
+    const states = {};
+    return new Proxy({}, {
+        get(target, prop) {
+            if (prop === 'init') {
+                return (...args) => Object.assign(states, initializer(...args));
+            }
+            if (prop === 'models') {
+                return models;
+            }
+            if (states[prop]) {
+                return states[prop];
+            }
+            throw new Error(`State ${String(prop)} may not be initialized`);
+        },
+    });
+}
+exports.createStateFactory = createStateFactory;