@abtnode/models 1.16.8-next-d1e52353

package/lib/models/blocklet.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBlockletModel = void 0;
+const sequelize_1 = require("sequelize");
+const util_1 = require("../util");
+function createBlockletModel() {
+    var _a;
+    return _a = class Blocklet extends sequelize_1.Model {
+            static initialize(sequelize) {
+                this.init({ ...this.GENESIS_ATTRIBUTES }, {
+                    sequelize,
+                    modelName: 'Blocklet',
+                    tableName: 'blocklets',
+                    indexes: [{ fields: ['appDid', 'id'] }, { fields: ['appPid', 'id'] }],
+                    timestamps: true,
+                });
+            }
+        },
+        _a.GENESIS_ATTRIBUTES = {
+            id: {
+                type: sequelize_1.DataTypes.STRING(40),
+                primaryKey: true,
+                defaultValue: util_1.generateId,
+            },
+            appDid: {
+                type: sequelize_1.DataTypes.STRING(40),
+                index: true,
+                allowNull: true,
+            },
+            appPid: {
+                type: sequelize_1.DataTypes.STRING(40),
+                index: true,
+                allowNull: true,
+            },
+            mode: {
+                type: sequelize_1.DataTypes.STRING(16),
+            },
+            meta: {
+                type: sequelize_1.DataTypes.JSON,
+            },
+            controller: {
+                type: sequelize_1.DataTypes.JSON,
+            },
+            status: {
+                type: sequelize_1.DataTypes.INTEGER,
+            },
+            source: {
+                type: sequelize_1.DataTypes.INTEGER,
+            },
+            bundleSource: {
+                type: sequelize_1.DataTypes.JSON,
+                defaultValue: {},
+            },
+            port: {
+                type: sequelize_1.DataTypes.NUMBER,
+            },
+            ports: {
+                type: sequelize_1.DataTypes.JSON,
+                defaultValue: {},
+            },
+            deployedFrom: {
+                type: sequelize_1.DataTypes.STRING(512),
+            },
+            environments: {
+                type: sequelize_1.DataTypes.JSON,
+                defaultValue: [],
+            },
+            children: {
+                type: sequelize_1.DataTypes.JSON,
+                defaultValue: [],
+            },
+            migratedFrom: {
+                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,
+            },
+            installedAt: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true,
+            },
+            stoppedAt: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true,
+            },
+            startedAt: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true,
+            },
+            pausedAt: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true,
+            },
+            externalSk: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+                defaultValue: true,
+            },
+            externalSkSource: {
+                type: sequelize_1.DataTypes.STRING(64),
+            },
+            structVersion: {
+                type: sequelize_1.DataTypes.STRING(16),
+            },
+            // TODO: deprecate this
+            structV1Did: {
+                type: sequelize_1.DataTypes.STRING(40),
+                defaultValue: '',
+            },
+        },
+        _a;
+}
+exports.createBlockletModel = createBlockletModel;

package/lib/models/cache.d.ts

@@ -0,0 +1,8 @@
+import { DynamicModel } from '../types';
+export type CacheState = {
+    key: string;
+    value: any;
+    createdAt: Date;
+    updatedAt: Date;
+};
+export declare function createCacheModel(): DynamicModel<CacheState>;

package/lib/models/cache.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCacheModel = void 0;
+// A simple persistent key-value storage
+const sequelize_1 = require("sequelize");
+const util_1 = require("../util");
+function createCacheModel() {
+    var _a;
+    return _a = class Cache extends sequelize_1.Model {
+            static initialize(sequelize) {
+                this.init({
+                    ...this.GENESIS_ATTRIBUTES,
+                }, {
+                    sequelize,
+                    modelName: 'Cache',
+                    tableName: 'caches',
+                    timestamps: true,
+                });
+            }
+        },
+        _a.GENESIS_ATTRIBUTES = {
+            key: {
+                type: sequelize_1.DataTypes.STRING(64),
+                primaryKey: true,
+                defaultValue: util_1.generateId,
+            },
+            value: {
+                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.createCacheModel = createCacheModel;

package/lib/models/certificate.d.ts

@@ -0,0 +1,7 @@
+import { TCertificate } from '@abtnode/types';
+import { DynamicModel } from '../types';
+export type CertificateState = Omit<TCertificate, 'name' | 'matchedSites' | 'status'> & {
+    privateKey: string;
+    public: boolean;
+};
+export declare function createCertificateModel(): DynamicModel<CertificateState>;

package/lib/models/certificate.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCertificateModel = void 0;
+// Storage for multi-queue job storage
+const sequelize_1 = require("sequelize");
+const util_1 = require("../util");
+function createCertificateModel() {
+    var _a;
+    return _a = class Certificate extends sequelize_1.Model {
+            static initialize(sequelize) {
+                this.init({
+                    ...this.GENESIS_ATTRIBUTES,
+                }, {
+                    sequelize,
+                    indexes: [{ fields: ['domain', 'id'] }],
+                    modelName: 'Certificate',
+                    tableName: 'certificates',
+                    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,
+                allowNull: false,
+            },
+            privateKey: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false,
+            },
+            certificate: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false,
+            },
+            isProtected: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+                defaultValue: false,
+            },
+            public: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+                defaultValue: false,
+            },
+            source: {
+                type: sequelize_1.DataTypes.STRING(32),
+                allowNull: false,
+            },
+            meta: {
+                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,
+            },
+        },
+        _a;
+}
+exports.createCertificateModel = createCertificateModel;

package/lib/models/connected-account.d.ts

@@ -0,0 +1,8 @@
+import { TConnectedAccount } from '@abtnode/types';
+import { DynamicModel } from '../types';
+export type ConnectedAccountState = TConnectedAccount & {
+    userDid: string;
+    firstLoginAt: Date;
+    lastLoginIp: string;
+};
+export declare function createConnectedAccountModel(): DynamicModel<ConnectedAccountState>;

package/lib/models/connected-account.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConnectedAccountModel = void 0;
+const sequelize_1 = require("sequelize");
+function createConnectedAccountModel() {
+    var _a;
+    return _a = class ConnectedAccount extends sequelize_1.Model {
+            static initialize(sequelize) {
+                this.init({
+                    ...this.GENESIS_ATTRIBUTES,
+                }, {
+                    sequelize,
+                    modelName: 'ConnectedAccount',
+                    tableName: 'connected_accounts',
+                    timestamps: false,
+                });
+            }
+            static associate(models) {
+                ConnectedAccount.belongsTo(models.User, {
+                    foreignKey: 'userDid',
+                    as: 'user',
+                });
+            }
+        },
+        _a.GENESIS_ATTRIBUTES = {
+            did: {
+                type: sequelize_1.DataTypes.STRING(40),
+                primaryKey: true,
+            },
+            pk: {
+                type: sequelize_1.DataTypes.STRING(256),
+            },
+            userDid: {
+                type: sequelize_1.DataTypes.STRING(40),
+                index: true,
+                references: {
+                    model: 'users',
+                    key: 'did',
+                },
+            },
+            provider: {
+                type: sequelize_1.DataTypes.STRING(32),
+            },
+            id: {
+                type: sequelize_1.DataTypes.STRING(64),
+            },
+            firstLoginAt: {
+                type: sequelize_1.DataTypes.DATE,
+            },
+            lastLoginAt: {
+                type: sequelize_1.DataTypes.DATE,
+            },
+            lastLoginIp: {
+                type: sequelize_1.DataTypes.STRING,
+            },
+        },
+        _a;
+}
+exports.createConnectedAccountModel = createConnectedAccountModel;

package/lib/models/connection.d.ts

@@ -0,0 +1,23 @@
+import { DynamicModel } from '../types';
+export type ConnectionState = {
+    id: string;
+    token: string;
+    status: string;
+    currentStep: number;
+    mfaSupported: boolean;
+    challenge: string;
+    sharedKey: string;
+    extraParams: Record<string, any>;
+    appInfo: Record<string, any>;
+    clientVersion: string;
+    encryptionKey: string;
+    connectedWallet: Record<string, string>;
+    did: string;
+    pk: string;
+    mfaCode: number;
+    appDid: string;
+    createdAt: Date;
+    updatedAt: Date;
+    [key: string]: any;
+};
+export declare function createConnectionModel(): DynamicModel<ConnectionState>;

package/lib/models/connection.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConnectionModel = void 0;
+// Storage for did-connect sessions
+const sequelize_1 = require("sequelize");
+function createConnectionModel() {
+    var _a;
+    return _a = class Connection extends sequelize_1.Model {
+            static initialize(sequelize) {
+                this.init({
+                    ...this.GENESIS_ATTRIBUTES,
+                }, {
+                    sequelize,
+                    modelName: 'Connection',
+                    tableName: 'connections',
+                    timestamps: true,
+                });
+            }
+        },
+        _a.GENESIS_ATTRIBUTES = {
+            token: {
+                type: sequelize_1.DataTypes.STRING(16),
+                primaryKey: true,
+            },
+            status: {
+                type: sequelize_1.DataTypes.STRING(16),
+                index: true,
+            },
+            currentStep: {
+                type: sequelize_1.DataTypes.INTEGER,
+            },
+            mfaSupported: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+                default: false,
+            },
+            challenge: {
+                type: sequelize_1.DataTypes.STRING(32),
+            },
+            sharedKey: {
+                type: sequelize_1.DataTypes.STRING(32),
+            },
+            extraParams: {
+                type: sequelize_1.DataTypes.JSON,
+            },
+            appInfo: {
+                type: sequelize_1.DataTypes.JSON,
+            },
+            clientVersion: {
+                type: sequelize_1.DataTypes.STRING(8),
+            },
+            encryptionKey: {
+                type: sequelize_1.DataTypes.STRING(512),
+            },
+            connectedWallet: {
+                type: sequelize_1.DataTypes.JSON,
+            },
+            did: {
+                type: sequelize_1.DataTypes.STRING(40),
+            },
+            pk: {
+                type: sequelize_1.DataTypes.STRING(128),
+            },
+            mfaCode: {
+                type: sequelize_1.DataTypes.INTEGER,
+            },
+            appDid: {
+                type: sequelize_1.DataTypes.STRING(40),
+            },
+            error: {
+                type: sequelize_1.DataTypes.STRING(256),
+            },
+            __extra: {
+                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,
+            },
+        },
+        _a;
+}
+exports.createConnectionModel = createConnectionModel;

package/lib/models/http-challenge.d.ts

@@ -0,0 +1,9 @@
+import { DynamicModel } from '../types';
+export type HttpChallengeState = {
+    id: string;
+    key: string;
+    value: string;
+    createdAt: Date;
+    updatedAt: Date;
+};
+export declare function createHttpChallengeModel(): DynamicModel<HttpChallengeState>;

package/lib/models/http-challenge.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHttpChallengeModel = void 0;
+const sequelize_1 = require("sequelize");
+const util_1 = require("../util");
+function createHttpChallengeModel() {
+    var _a;
+    return _a = class HttpChallenge extends sequelize_1.Model {
+            static initialize(sequelize) {
+                this.init({
+                    ...this.GENESIS_ATTRIBUTES,
+                }, {
+                    sequelize,
+                    indexes: [{ fields: ['key', 'id'] }],
+                    modelName: 'HttpChallenge',
+                    tableName: 'http_challenges',
+                    timestamps: true,
+                });
+            }
+        },
+        _a.GENESIS_ATTRIBUTES = {
+            id: {
+                type: sequelize_1.DataTypes.STRING(40),
+                primaryKey: true,
+                defaultValue: util_1.generateId,
+            },
+            key: {
+                type: sequelize_1.DataTypes.STRING(255),
+                unique: true,
+                allowNull: false,
+            },
+            value: {
+                type: sequelize_1.DataTypes.STRING(512),
+                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.createHttpChallengeModel = createHttpChallengeModel;

package/lib/models/index.d.ts

@@ -0,0 +1,63 @@
+import { Sequelize } from 'sequelize';
+export * from './message';
+export * from './account';
+export * from './certificate';
+export * from './http-challenge';
+export * from './user';
+export * from './passport';
+export * from './connected-account';
+export * from './session';
+export * from './rbac';
+export * from './access-key';
+export * from './audit-log';
+export * from './blocklet-extra';
+export * from './blocklet';
+export * from './cache';
+export * from './job';
+export * from './migration';
+export * from './notification';
+export * from './server';
+export * from './site';
+export * from './webhook';
+export * from './connection';
+export * from './backup';
+export declare function createSequelize(dbPath: string, config?: Record<string, any>): any;
+export declare function getServiceModels(): {
+    Message: import("../types").DynamicModel<import("./message").MessageState>;
+};
+export declare function getCertificateManagerModels(): {
+    Account: import("../types").DynamicModel<import("./account").AccountState>;
+    Certificate: import("../types").DynamicModel<import("./certificate").CertificateState>;
+    HttpChallenge: import("../types").DynamicModel<import("./http-challenge").HttpChallengeState>;
+    Job: import("../types").DynamicModel<import("./job").JobState>;
+};
+export declare function getBlockletModels(): {
+    User: import("../types").DynamicModel<import("./user").UserState>;
+    Passport: import("../types").DynamicModel<import("./passport").PassportState>;
+    ConnectedAccount: import("../types").DynamicModel<import("./connected-account").ConnectedAccountState>;
+    Session: import("../types").DynamicModel<import("./session").SessionState>;
+    Rbac: import("../types").DynamicModel<import("./rbac").RbacState>;
+};
+export declare function getServerModels(): {
+    AccessKey: import("../types").DynamicModel<import("./access-key").AccessKeyState>;
+    AuditLog: import("../types").DynamicModel<import("./audit-log").AuditLogState>;
+    BlockletExtra: import("../types").DynamicModel<import("./blocklet-extra").BlockletExtraState>;
+    Blocklet: import("../types").DynamicModel<import("./blocklet").BlockletState>;
+    Cache: import("../types").DynamicModel<import("./cache").CacheState>;
+    Job: import("../types").DynamicModel<import("./job").JobState>;
+    Migration: import("../types").DynamicModel<import("./migration").MigrationState>;
+    Notification: import("../types").DynamicModel<import("@abtnode/types").TNotification>;
+    Rbac: import("../types").DynamicModel<import("./rbac").RbacState>;
+    Server: import("../types").DynamicModel<import("./server").ServerState>;
+    Session: import("../types").DynamicModel<import("./session").SessionState>;
+    Site: import("../types").DynamicModel<import("./site").SiteState>;
+    User: import("../types").DynamicModel<import("./user").UserState>;
+    Passport: import("../types").DynamicModel<import("./passport").PassportState>;
+    ConnectedAccount: import("../types").DynamicModel<import("./connected-account").ConnectedAccountState>;
+    WebHook: import("../types").DynamicModel<import("./webhook").WebHookState>;
+    Backup: import("../types").DynamicModel<import("./backup").BackupState>;
+};
+export declare function getConnectModels(): {
+    Connection: import("../types").DynamicModel<import("./connection").ConnectionState>;
+};
+export declare function setupModels(models: any, sequelize: Sequelize): void;