@nextage/nx-frame-be 1.0.1

package/build/common/manager/socket-io-cli-manager.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketIoCliManager = void 0;
+const events_1 = __importDefault(require("events"));
+const socket_io_client_1 = require("socket.io-client");
+const constants_1 = require("../constants");
+const utils_1 = require("../utils");
+class SocketIoCliManager extends events_1.default {
+    constructor(host, port, params = { reconnection: true }, logger) {
+        super();
+        this.protocol = 'http';
+        this._listeners = {};
+        this._logCtx = (0, utils_1.logClassCtx)(this);
+        this.params = params;
+        this.host = host;
+        this.port = port;
+        this.logger = logger || constants_1.APP.logger;
+        this.init();
+    }
+    /**
+     * Init Socket
+     *
+     * @param {*} encoding
+     */
+    init(encoding) {
+        var _a, _b;
+        this.uri = `${this.protocol}://${this.host}:${this.port}`;
+        this.manager = new socket_io_client_1.Manager(this.uri, this.params);
+        this.socket = this.manager.socket('/');
+        // this.client = io.connect(this.uri, this.params);
+        (_a = this.socket) === null || _a === void 0 ? void 0 : _a.on('connect', () => this.onConnect());
+        (_b = this.socket) === null || _b === void 0 ? void 0 : _b.on("disconnect", () => this.onDisconnect());
+    }
+    /**
+     *
+     */
+    onConnect() {
+        this.logger.info(`Socket.io connected to server: ${this.uri}`, this._logCtx);
+    }
+    /**
+     *
+     */
+    onDisconnect() {
+        this.logger.info(`Socket.io disconnected from server: ${this.uri}`, this._logCtx);
+    }
+    /**
+     * Format and send message
+     * @param {*} event
+     * @param {*} data
+     * @param {*} callback
+     */
+    sendData(event, data, callback) {
+        var _a;
+        (_a = this.socket) === null || _a === void 0 ? void 0 : _a.emit(event, data, callback);
+    }
+    /**
+     *
+     * @param {*} event
+     * @param {*} callback
+     */
+    addEventListener(event, callback) {
+        var _a;
+        if (this._listeners[event])
+            this.removeEventListener(event);
+        if (!callback)
+            callback = (data) => this.logger.info(`Socket.io receved data: ${event} - ${data}`, this._logCtx);
+        this._listeners[event] = callback;
+        (_a = this.socket) === null || _a === void 0 ? void 0 : _a.on(event, callback);
+    }
+    /**
+     *
+     * @param {*} event
+     * @param {*} callback
+     */
+    removeEventListener(event) {
+        var _a;
+        (_a = this.socket) === null || _a === void 0 ? void 0 : _a.off(event);
+        delete this._listeners[event];
+    }
+    /**
+     * Close Socket
+     */
+    close() {
+        var _a;
+        (_a = this.socket) === null || _a === void 0 ? void 0 : _a.disconnect();
+    }
+}
+exports.SocketIoCliManager = SocketIoCliManager;

package/build/common/manager/tunnel-manager.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+import { TunnelOptions } from 'tunnel-ssh';
+import { ForwardOptions, ServerOptions } from 'tunnel-ssh';
+import { SshOptions } from 'tunnel-ssh';
+import { Server } from 'net';
+export declare class TunnelManager {
+    private readonly tunnelOptions;
+    private readonly serverOptions;
+    private readonly sshOptions;
+    private readonly forwardOptions;
+    private readonly logger;
+    private readonly tnl?;
+    private server?;
+    constructor(config: {
+        tunnel: TunnelOptions;
+        server: ServerOptions;
+        ssh: SshOptions;
+        forward: ForwardOptions;
+    }, logger?: any);
+    /**
+     *
+     */
+    open(): Promise<Server | undefined>;
+    /**
+     *
+     */
+    close(): void;
+}

package/build/common/manager/tunnel-manager.js

@@ -0,0 +1,49 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TunnelManager = void 0;
+const tunnel_ssh_1 = require("tunnel-ssh");
+const constants_1 = require("../constants");
+const utils_1 = require("../utils");
+class TunnelManager {
+    constructor(config, logger) {
+        this.logger = logger !== null && logger !== void 0 ? logger : constants_1.APP.logger;
+        // tunnel config
+        this.tunnelOptions = config.tunnel;
+        this.serverOptions = config.server;
+        this.sshOptions = config.ssh;
+        this.forwardOptions = config.forward;
+    }
+    /**
+     *
+     */
+    open() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let [server, conn] = yield (0, tunnel_ssh_1.createTunnel)(this.tunnelOptions, this.serverOptions, this.sshOptions, this.forwardOptions);
+                this.server = server;
+                this.logger.info('tunnel established');
+            }
+            catch (err) {
+                this.logger.error(`%o`, err, (0, utils_1.logClassCtx)(this));
+            }
+            return this.server;
+        });
+    }
+    /**
+     *
+     */
+    close() {
+        var _a;
+        (_a = this.tnl) === null || _a === void 0 ? void 0 : _a.end();
+    }
+}
+exports.TunnelManager = TunnelManager;

package/build/common/models/coded-entity.controller.d.ts

@@ -0,0 +1,5 @@
+import { BaseController } from '../base/base.controller';
+import { CodedEntity, CodedEntityAttrs, CodedEntityDoc } from './coded-entity.model';
+export declare class CodedEntityCtrl extends BaseController<CodedEntityAttrs, CodedEntityDoc, CodedEntity> {
+}
+export declare const ceCtrl: CodedEntityCtrl;

package/build/common/models/coded-entity.controller.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ceCtrl = exports.CodedEntityCtrl = void 0;
+const base_controller_1 = require("../base/base.controller");
+const coded_entity_model_1 = require("./coded-entity.model");
+class CodedEntityCtrl extends base_controller_1.BaseController {
+}
+exports.CodedEntityCtrl = CodedEntityCtrl;
+exports.ceCtrl = new CodedEntityCtrl({ model: coded_entity_model_1.ceModel });

package/build/common/models/coded-entity.model.d.ts

@@ -0,0 +1,25 @@
+import { NxObject } from '../interfaces';
+import { BaseMongoDoc, BaseMongoModel } from '../base/base.interfaces';
+import { BaseModel } from '../base/base.model';
+export interface CodedEntityAttrs {
+    id?: string;
+    code?: string;
+    name?: string;
+    data?: {
+        items: NxObject[];
+    };
+    version?: number;
+}
+export interface CodedEntityDoc extends BaseMongoDoc {
+    code: string;
+    name: string;
+    data: {
+        items: NxObject[];
+    };
+    version: number;
+}
+export interface CodedEntityModel extends BaseMongoModel<CodedEntityAttrs, CodedEntityDoc> {
+}
+export declare class CodedEntity extends BaseModel<CodedEntityAttrs, CodedEntityDoc, CodedEntityModel> {
+}
+export declare const ceModel: CodedEntity;

package/build/common/models/coded-entity.model.js

@@ -0,0 +1,51 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ceModel = exports.CodedEntity = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const base_model_1 = require("../base/base.model");
+const mongo_utils_1 = require("../base/mongo-utils");
+class CodedEntity extends base_model_1.BaseModel {
+}
+exports.CodedEntity = CodedEntity;
+const schema = {
+    code: {
+        type: String,
+        required: true,
+    },
+    name: {
+        type: String,
+        required: true,
+    },
+    data: {
+        type: mongoose_1.default.SchemaTypes.Mixed,
+        required: true,
+    }
+};
+const params = {
+    name: 'CodedEntity',
+    modelName: 'CodedEntity',
+    collection: 'codedEntity',
+    classDef: CodedEntity,
+    mergeSchema: false,
+    modelParams: { sort: { name: 1 }, CRUDEvents: true },
+    schema
+};
+exports.ceModel = (0, mongo_utils_1.createModel)(params, false);
+exports.ceModel.mgModel.schema.pre('save', function (done) {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log('CIAONE');
+        done();
+    });
+});

package/build/common/models/user.model.d.ts

@@ -0,0 +1,56 @@
+import { BaseUser, NxObject } from '../interfaces';
+import { BaseMongoDoc, BaseMongoModel } from '../base/base.interfaces';
+import { BaseModel } from '../base/base.model';
+import { BaseDBItem } from '../types';
+export interface UserAttrs extends BaseDBItem {
+    username: string;
+    profile: UserAttrProfile;
+    roles: string[];
+    services?: UserAttrService;
+    data?: NxObject;
+    active?: boolean;
+    createdBy?: string;
+    createdAt?: Date;
+    updatedBy?: string;
+    updatedAt?: Date;
+    deletedBy?: string;
+    deletedAt?: Date;
+    version: number;
+}
+export interface UserAttrProfile {
+    firstname?: string;
+    lastname?: string;
+    email?: string;
+}
+export interface UserAttrService {
+    password?: {
+        hash?: string;
+        salt?: string;
+        expiresAt?: Date;
+    };
+    resetPassword?: {
+        token?: string;
+        expiresAt?: Date;
+    };
+    pb?: string;
+}
+export interface UserDoc extends BaseMongoDoc, BaseUser {
+    username: string;
+    profile: UserAttrProfile;
+    roles: string[];
+    services?: UserAttrService;
+    data?: NxObject;
+    active?: boolean;
+    createdBy?: string;
+    createdAt?: Date;
+    updatedBy?: string;
+    updatedAt?: Date;
+    deletedBy?: string;
+    deletedAt?: Date;
+    version: number;
+}
+export interface UserModel extends BaseMongoModel<UserAttrs, UserDoc> {
+}
+export declare class User extends BaseModel<UserAttrs, UserDoc, UserModel> {
+}
+export declare const users: User;

package/build/common/models/user.model.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.users = exports.User = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const base_model_1 = require("../base/base.model");
+const mongo_utils_1 = require("../base/mongo-utils");
+const constants_1 = require("../constants");
+const utils_1 = require("../utils");
+class User extends base_model_1.BaseModel {
+}
+exports.User = User;
+const required = true;
+const unique = true;
+const secret = constants_1.APP.dataScr || process.env.SECRET || '';
+const get = (text) => constants_1.cryptoUtils.decryptText(text, secret);
+const set = (text) => constants_1.cryptoUtils.encryptText(text, secret);
+const schema = {
+    username: { type: String, required, unique },
+    email: { type: String, required, get, set },
+    password: String,
+    services: {
+        password: { hash: { type: String }, salt: { type: String }, expiresAt: Date },
+        resetPassword: { token: { type: String }, expiresAt: { type: Date } },
+        //resume       : { loginTokens: [{ when: { type: Date }, hashedToken: { type: String } }]},
+        pb: { type: String }
+    },
+    profile: {
+        lastname: { type: String, get, set },
+        firstname: { type: String, get, set },
+        email: { type: String, get, set },
+    },
+    //functs        : [String],
+    //organizations : [mongoose.SchemaTypes.Mixed],
+    roles: [String],
+    data: mongoose_1.default.SchemaTypes.Mixed,
+    // delegations: {
+    //   functs: [mongoose.SchemaTypes.Mixed],
+    //   roles : [mongoose.SchemaTypes.Mixed],
+    // },
+    // config   : mongoose.SchemaTypes.Mixed,
+    createdBy: mongoose_1.default.SchemaTypes.ObjectId,
+    createdAt: Date,
+    updatedBy: mongoose_1.default.SchemaTypes.ObjectId,
+    updatedAt: Date,
+    deleted: { type: Boolean, default: false },
+    deletedAt: Date,
+    active: { type: Boolean, default: false }
+};
+const params = {
+    name: 'User',
+    modelName: 'User',
+    collection: 'users',
+    classDef: User,
+    mergeSchema: false,
+    modelParams: { sort: { name: 1 }, CRUDEvents: true },
+    schema
+};
+exports.users = (0, mongo_utils_1.createModel)(params, false);
+// users.mgModel.prototype.validPassword = function(password) {
+//   return bcrypt.compareSync(password, this.services.password.hash);
+// };
+exports.users.mgModel.prototype.hasRole = function (role) {
+    if (Array.isArray(role))
+        return (0, utils_1.containsArrayValue)(this.roles, role);
+    return !!this.roles.find((r) => r === role);
+};
+// users.mgModel.prototype.isAdmin = function() {
+//   return !!this.roles.find((r: string) => r === BASE_ROLES.ADMIN);
+// };

package/build/common/types.d.ts

@@ -0,0 +1,136 @@
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/inferschematype" />
+/// <reference types="mongoose/types/inferrawdoctype" />
+import { Mongoose } from 'mongoose';
+import { Sequelize } from 'sequelize';
+import { Algorithm } from 'jsonwebtoken';
+import { Express } from 'express';
+import { AppStatus } from './enums';
+import { ChangeStreamData } from './base/base.interfaces';
+import { BaseModel } from './base/base.model';
+import { NxObject, NxTypeObject } from './interfaces';
+import { PubSubManager } from './manager/pubsub-manager';
+import { ShutdownManager } from './manager/shutdown-manager';
+export type NxDateRage = {
+    from?: Date;
+    to?: Date;
+    eq?: Date;
+};
+export type BaseDBItem = {
+    id?: string;
+};
+export type AppData = {
+    app?: Express;
+    logger: any;
+    appName: string;
+    prodMode: boolean;
+    status?: AppStatus;
+    dataScr?: string;
+    mongoModels: NxTypeObject<BaseModel<any, any, any>>;
+    mongoose?: Mongoose;
+    sqlz?: Sequelize;
+    nxPubSub: PubSubManager;
+    shutdownMng?: ShutdownManager;
+    streams: ChangeStreamData[];
+    config: AppConfig;
+};
+export type AppConfig = {
+    endpoint: AppEndpoint;
+    email: AppEmail;
+    jwt: AppJwt;
+    aws: AppAWS;
+    msg: AppMessages;
+    mongo: AppMongoDB;
+    invite: AppInvitation;
+    logging: AppLogging;
+};
+export type AppMongoDB = {
+    auth?: {
+        us: string;
+        pw: string;
+    };
+    dbname?: string;
+    host?: string;
+    port?: string;
+    protocol?: string;
+    options?: NxObject;
+    ssl?: boolean;
+    tnlHost?: string;
+    tnlPort?: string;
+    tnlAuth?: {
+        us?: string;
+        pw?: string;
+        key?: string;
+    };
+};
+export type AppInvitation = {
+    validity?: string | number;
+};
+export type AppLogging = {
+    format?: string;
+    dir?: string;
+    filename?: string;
+};
+export type AppMessages = {
+    servers?: string | string[];
+    clientId?: string;
+    clientName?: string;
+    clientType?: 'nats' | 'msg';
+    ackWait?: number;
+    maxDeliver?: number;
+};
+export type AppEndpoint = {
+    rest?: string;
+    graphql?: string;
+    graphqlWs?: string;
+    ws?: boolean;
+    port?: number;
+};
+export type AppJwt = {
+    secret?: string;
+    algorithm?: Algorithm;
+    duration?: string;
+};
+export type AppEmail = {
+    source?: string;
+    aws?: boolean;
+};
+export type AppAWS = {
+    region?: string;
+};
+/**
+ * const endpoint = {
+  http: process.env.GRAPHQL_ENDPOINT    || '/api/graphql',
+  ws  : process.env.GRAPHQL_WS_ENDPOINT || '/subscriptions',
+  wsOn: !!process.env.GRAPHQL_WS,
+  port: process.env.SERVER_PORT ? parseInt(process.env.SERVER_PORT) : 4200
+};
+
+const jwtData      = {
+  secret   : process.env.JWT_SECRET,
+  algorithm: (process.env.JWT_ALGORITHM || 'HS512') as unknown as Algorithm,
+  duration : process.env.JWT_VALIDITY  || '1h'
+};
+ */ 

package/build/common/types.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * const endpoint = {
+  http: process.env.GRAPHQL_ENDPOINT    || '/api/graphql',
+  ws  : process.env.GRAPHQL_WS_ENDPOINT || '/subscriptions',
+  wsOn: !!process.env.GRAPHQL_WS,
+  port: process.env.SERVER_PORT ? parseInt(process.env.SERVER_PORT) : 4200
+};
+
+const jwtData      = {
+  secret   : process.env.JWT_SECRET,
+  algorithm: (process.env.JWT_ALGORITHM || 'HS512') as unknown as Algorithm,
+  duration : process.env.JWT_VALIDITY  || '1h'
+};
+ */