@ealforque/sequelize-field-parser 1.0.1

package/README.md

@@ -0,0 +1,62 @@
+# Sequelize Field Parser Package
+
+![npm version](https://img.shields.io/npm/v/sequelize-field-parser)
+![build](https://img.shields.io/github/workflow/status/ealforque/sequelize-field-parser/CI)
+
+## Description
+
+A TypeScript utility for Sequelize models that lets users specify fields to include in queries and automatically builds the `include` parameter for Sequelize. It simplifies selecting fields and relationships, making complex query construction and model association management more efficient.
+
+## Features
+
+- Parse Sequelize model fields and relationships
+- Generate field trees for complex models
+- Type-safe interfaces and types
+- Easy integration with MySQL via Sequelize
+- Test-driven development with Jest
+
+## Installation
+
+```bash
+npm install ealforque/sequelize-field-parser
+```
+
+## Usage
+
+Import and use in your project:
+
+```typescript
+import FieldParserService from "sequelize-field-parser";
+import Status from "./path/to/status.model";
+
+const parser = new FieldParserService();
+
+// query parameter
+// api/resource?fields='status.uuid,status.name,status.category.uuid,status.category.name'
+const queryParams =
+  "status.uuid,status.name,status.category.uuid,status.category.name";
+
+// Parse the query parameter
+const { columns, relationshipTree } = parser.parseFields(queryParams, Model);
+
+// Build the sequelize include
+const include = parser.buildSequelizeInclude(relationshipTree, Model);
+
+console.log(include);
+/* Example output:
+[
+  {
+    model: Status,
+    as: 'status',
+    attributes: ['uuid', 'name'],
+    include: [
+      {
+        model: Category,
+        as: 'category',
+        attributes: ['uuid', 'name'],
+      }
+    ]
+  }
+]
+*/
+```

package/dist/field_parser.service.d.ts

@@ -0,0 +1,13 @@
+import { IncludeOptions, Model, ModelStatic } from "sequelize";
+import ModelStaticWithFields from "./interfaces/model_fields.interface";
+import { RelationshipTree } from "./types/model.relationship.tree.type";
+declare class FieldParserService {
+    private fields;
+    constructor();
+    parseFields: <M extends Model>(fields: string, model: ModelStaticWithFields<M>) => {
+        columns: string[];
+        relationshipTree: RelationshipTree;
+    };
+    buildSequelizeInclude: <M extends Model>(tree: RelationshipTree, model: ModelStatic<M>) => IncludeOptions[];
+}
+export default FieldParserService;

package/dist/field_parser.service.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class FieldParserService {
+    fields;
+    constructor() {
+        this.fields = [];
+    }
+    parseFields = (fields, model) => {
+        this.fields = fields
+            .split(",")
+            .map((f) => f.trim())
+            .filter((f) => f.length > 0);
+        const relationshipTree = {};
+        const columns = [...model.DEFAULT_FIELDS];
+        const selectableFields = model.SELECTABLE_FIELDS;
+        for (const field of this.fields) {
+            const segments = field.split(".");
+            if (segments.length === 1) {
+                const topField = segments[0];
+                if (selectableFields.includes(topField)) {
+                    columns.push(topField);
+                }
+            }
+            else {
+                let relationship = relationshipTree;
+                for (let i = 0; i < segments.length; i++) {
+                    const field = segments[i];
+                    if (!relationship[field]) {
+                        relationship[field] = i === segments.length - 1 ? true : {};
+                    }
+                    if (relationship[field] !== true) {
+                        relationship = relationship[field];
+                    }
+                }
+            }
+        }
+        return { columns, relationshipTree };
+    };
+    buildSequelizeInclude = (tree, model) => {
+        const includeOptions = Object.entries(tree).flatMap(([relation, nested]) => {
+            const relationship = model.associations?.[relation];
+            if (!relationship || !relationship.target)
+                return [];
+            const currentModel = relationship.target;
+            const selectableFields = currentModel.SELECTABLE_FIELDS;
+            if (nested === true) {
+                return {
+                    model: currentModel,
+                    as: relation,
+                    attributes: [],
+                };
+            }
+            const deeperIncludes = this.buildSequelizeInclude(nested, currentModel);
+            const leafAttributes = Object.entries(nested)
+                .filter(([, value]) => value === true)
+                .map(([key]) => key)
+                .filter((attr) => selectableFields.includes(attr));
+            return {
+                model: currentModel,
+                as: relation,
+                attributes: leafAttributes,
+                include: deeperIncludes,
+            };
+        });
+        return includeOptions;
+    };
+}
+exports.default = FieldParserService;

package/dist/interfaces/model_fields.interface.d.ts

@@ -0,0 +1,5 @@
+import { Model, ModelStatic } from "sequelize";
+export default interface ModelStaticWithFields<T extends Model> extends ModelStatic<T> {
+    DEFAULT_FIELDS: string[];
+    SELECTABLE_FIELDS: string[];
+}

package/dist/interfaces/model_fields.interface.js

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

package/dist/types/model.relationship.tree.type.d.ts

@@ -0,0 +1,3 @@
+export type RelationshipTree = {
+    [key: string]: RelationshipTree | true;
+};

package/dist/types/model.relationship.tree.type.js

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

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@ealforque/sequelize-field-parser",
+  "version": "1.0.1",
+  "main": "dist/field_parser.service.js",
+  "types": "dist/field_parser.service.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && tsc",
+    "test": "jest --clearCache && jest --coverage --detectOpenHandles",
+    "format": "prettier --write .",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "sequelize": "^6.0.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "eslint": "^9.26.0",
+    "eslint-config-prettier": "^10.1.3",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-simple-import-sort": "^12.1.1",
+    "http-status-codes": "^2.3.0",
+    "jest": "^29.7.0",
+    "prettier": "^3.5.3",
+    "sequelize-cli": "^6.6.2",
+    "supertest": "^7.1.0",
+    "ts-jest": "^29.3.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.32.0"
+  }
+}