@abtnode/models 1.16.8-next-d1e52353

package/lib/types.d.ts

@@ -0,0 +1,49 @@
+import { ModelDefined } from 'sequelize';
+export type DynamicModel<T> = ModelDefined<T, T> & {
+    initialize: (sequelize: any) => void;
+    GENESIS_ATTRIBUTES: {
+        [key: string]: any;
+    };
+};
+export type QueryInterface = {
+    createTable: Function;
+    dropTable: Function;
+};
+export type UpdateOptions = {
+    returnUpdatedDocs?: boolean;
+};
+export type AnyObject = {
+    [x: string]: any;
+};
+export type SortOptions<T> = {
+    [x in keyof T]?: 1 | -1;
+};
+export type SelectOptions<T> = {
+    [x in keyof T]?: 0 | 1;
+};
+export type PagingOptions = {
+    pageSize?: number;
+    page?: number;
+};
+export type ApplyBasicQueryCasting<T> = T | T[] | (T extends (infer U)[] ? U : any) | any;
+export type Condition<T> = ApplyBasicQueryCasting<T> | QuerySelector<ApplyBasicQueryCasting<T>>;
+export type ConditionOptions<T> = {
+    [P in keyof T]?: Condition<T[P]>;
+} & RootQuerySelector<T>;
+export type QuerySelector<T> = {
+    $lt?: T;
+    $lte?: T;
+    $gt?: T;
+    $gte?: T;
+    $in?: T[];
+    $nin?: T[];
+    $ne?: T;
+    $exists?: boolean;
+    $regex?: T extends string ? RegExp | string : never;
+};
+export type RootQuerySelector<T> = {
+    $and?: Array<ConditionOptions<T>>;
+    $or?: Array<ConditionOptions<T>>;
+    $not?: Array<ConditionOptions<T>>;
+    [key: string]: any;
+};

package/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/util.d.ts

@@ -0,0 +1,6 @@
+import { FindOptions, IncludeOptions, Order } from 'sequelize';
+export declare function generateId(): string;
+export declare function formatConditions(conditions: Record<string, any>): IncludeOptions;
+export declare function formatOrder(sort: Record<string, any>): Order;
+export declare function formatSelection(selection: Record<string, any>): string[];
+export declare function formatParams(params: FindOptions): FindOptions;

package/lib/util.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatParams = exports.formatSelection = exports.formatOrder = exports.formatConditions = exports.generateId = void 0;
+const uuid_1 = require("uuid");
+const sequelize_1 = require("sequelize");
+const lodash_isempty_1 = __importDefault(require("lodash.isempty"));
+function generateId() {
+    return (0, uuid_1.v4)();
+}
+exports.generateId = generateId;
+function formatConditions(conditions) {
+    if (conditions.where || conditions.include) {
+        return conditions;
+    }
+    const where = {};
+    for (const [field, value] of Object.entries(conditions)) {
+        if (field === '$or' && Array.isArray(value)) {
+            where[sequelize_1.Op.or] = value.map((x) => formatConditions(x).where);
+        }
+        else if (value && typeof value === 'object' && !Array.isArray(value)) {
+            const operators = [];
+            for (const [operator, operand] of Object.entries(value)) {
+                switch (operator) {
+                    case '$lt':
+                        operators.push({ [sequelize_1.Op.lt]: operand });
+                        break;
+                    case '$lte':
+                        operators.push({ [sequelize_1.Op.lte]: operand });
+                        break;
+                    case '$gt':
+                        operators.push({ [sequelize_1.Op.gt]: operand });
+                        break;
+                    case '$gte':
+                        operators.push({ [sequelize_1.Op.gte]: operand });
+                        break;
+                    case '$ne':
+                        operators.push({ [sequelize_1.Op.ne]: operand });
+                        break;
+                    case '$in':
+                        operators.push({ [sequelize_1.Op.in]: operand });
+                        break;
+                    case '$nin':
+                        operators.push({ [sequelize_1.Op.notIn]: operand });
+                        break;
+                    case '$exists':
+                        operators.push(operand ? { [sequelize_1.Op.not]: null } : { [sequelize_1.Op.is]: null });
+                        break;
+                    case '$regex':
+                        operators.push({ [sequelize_1.Op.like]: `%${operand}%` });
+                        break;
+                    default:
+                        operators.push({ [operator]: operand });
+                }
+            }
+            if (operators.length === 1) {
+                // eslint-disable-next-line prefer-destructuring
+                where[field] = operators[0];
+            }
+            else if (operators.length > 1) {
+                where[field] = { [sequelize_1.Op.and]: operators };
+            }
+        }
+        else {
+            where[field] = value;
+        }
+    }
+    return { where };
+}
+exports.formatConditions = formatConditions;
+function formatOrder(sort) {
+    const order = [];
+    for (const [field, value] of Object.entries(sort)) {
+        if (value === 1) {
+            order.push([field, 'ASC']);
+        }
+        else if (value === -1) {
+            order.push([field, 'DESC']);
+        }
+        else {
+            console.warn(`Unsupported sort value for field "${field}": ${value}. Only -1 and 1 are supported.`);
+        }
+    }
+    return order;
+}
+exports.formatOrder = formatOrder;
+function formatSelection(selection) {
+    const attributes = [];
+    for (const [field, value] of Object.entries(selection)) {
+        if (value === 1) {
+            attributes.push(field);
+        }
+        else if (value !== 0) {
+            console.warn(`Unsupported projection value for field "${field}": ${value}. Only 0 and 1 are supported.`);
+        }
+    }
+    return attributes;
+}
+exports.formatSelection = formatSelection;
+function formatParams(params) {
+    if ((0, lodash_isempty_1.default)(params.attributes)) {
+        delete params.attributes;
+    }
+    return params;
+}
+exports.formatParams = formatParams;

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@abtnode/models",
+  "version": "1.16.8-next-d1e52353",
+  "description": "Sequelize models for blocklet server and blocklet service",
+  "homepage": "https://github.com/ArcBlock/blocklet-server#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "lib/index.js",
+  "scripts": {
+    "lint": "eslint src",
+    "lint:fix": "eslint src --fix",
+    "test": "MIGRATION_SCRIPT_EXTENSION=ts node tools/jest.js",
+    "coverage": "npm run test -- --coverage",
+    "clean": "rm -fr lib",
+    "build": "npm run clean && tsc && rm -f lib/migrations/*/*.d.ts"
+  },
+  "files": [
+    "lib"
+  ],
+  "author": {
+    "name": "wangshijun",
+    "email": "shijun@arcblock.io",
+    "url": "https://github.com/wangshijun"
+  },
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ArcBlock/blocklet-server"
+  },
+  "bugs": {
+    "url": "https://github.com/ArcBlock/blocklet-server/issues"
+  },
+  "dependencies": {
+    "@abtnode/types": "1.16.8-next-d1e52353",
+    "@nedb/core": "^2.1.5",
+    "lodash.clonedeep": "^4.5.0",
+    "lodash.get": "^4.4.2",
+    "lodash.isempty": "^4.4.0",
+    "sequelize": "^6.31.0",
+    "sqlite3": "^5.1.6",
+    "umzug": "^3.2.1",
+    "uuid": "^8.3.2"
+  },
+  "devDependencies": {
+    "@arcblock/eslint-config-ts": "^0.2.3",
+    "@types/jest": "^29.2.0",
+    "@types/node": "^18.11.0",
+    "@typescript-eslint/eslint-plugin": "^5.40.1",
+    "@typescript-eslint/parser": "^5.40.1",
+    "jest": "^27.5.1",
+    "ts-jest": "^27.1.5",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.8.4"
+  },
+  "resolutions": {},
+  "gitHead": "d357376aa3df9ef789befc7f548629deecb04d96"
+}