@alpha.consultings/eloquent-orm.js 1.0.1

package/dist/index.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isModelRegistryStrictMode = exports.setModelRegistryStrictMode = exports.isModelRegistered = exports.registerModels = exports.setupCache = exports.CacheManager = exports.SchemaBuilder = exports.SchemaValidator = exports.validateSchema = exports.mixin = exports.relation = exports.validate = exports.column = exports.CoreModel = exports.Factory = exports.PivotHelperMixin = exports.MorphRegistry = exports.MongoModel = exports.SqlModel = exports.Model = exports.BaseModel = void 0;
+/**
+ * Public package entrypoint.
+ * Only exports from this file are semver-tracked and supported for consumers.
+ * Deep imports into internal `dist/core/*`, `dist/cli/*`, or `src/*` paths are private.
+ */
+var BaseModel_1 = require("./core/model/BaseModel");
+Object.defineProperty(exports, "BaseModel", { enumerable: true, get: function () { return BaseModel_1.BaseModel; } });
+Object.defineProperty(exports, "Model", { enumerable: true, get: function () { return BaseModel_1.Model; } });
+Object.defineProperty(exports, "SqlModel", { enumerable: true, get: function () { return BaseModel_1.SqlModel; } });
+Object.defineProperty(exports, "MongoModel", { enumerable: true, get: function () { return BaseModel_1.MongoModel; } });
+Object.defineProperty(exports, "MorphRegistry", { enumerable: true, get: function () { return BaseModel_1.MorphRegistry; } });
+var PivotHelperMixin_1 = require("./core/orm/mixins/PivotHelperMixin");
+Object.defineProperty(exports, "PivotHelperMixin", { enumerable: true, get: function () { return PivotHelperMixin_1.PivotHelperMixin; } });
+var Factory_1 = require("./cli/utils/factories/Factory");
+Object.defineProperty(exports, "Factory", { enumerable: true, get: function () { return Factory_1.Factory; } });
+var CoreModel_1 = require("./core/model/CoreModel");
+Object.defineProperty(exports, "CoreModel", { enumerable: true, get: function () { return CoreModel_1.CoreModel; } });
+var SchemaBlueprint_1 = require("./core/schema/SchemaBlueprint");
+Object.defineProperty(exports, "column", { enumerable: true, get: function () { return SchemaBlueprint_1.column; } });
+Object.defineProperty(exports, "validate", { enumerable: true, get: function () { return SchemaBlueprint_1.validate; } });
+Object.defineProperty(exports, "relation", { enumerable: true, get: function () { return SchemaBlueprint_1.relation; } });
+Object.defineProperty(exports, "mixin", { enumerable: true, get: function () { return SchemaBlueprint_1.mixin; } });
+Object.defineProperty(exports, "validateSchema", { enumerable: true, get: function () { return SchemaBlueprint_1.validateSchema; } });
+var SchemaValidator_1 = require("./core/schema/SchemaValidator");
+Object.defineProperty(exports, "SchemaValidator", { enumerable: true, get: function () { return SchemaValidator_1.SchemaValidator; } });
+var SchemaBuilder_1 = require("./core/schema/SchemaBuilder");
+Object.defineProperty(exports, "SchemaBuilder", { enumerable: true, get: function () { return SchemaBuilder_1.SchemaBuilder; } });
+var CacheManager_1 = require("./core/cache/CacheManager");
+Object.defineProperty(exports, "CacheManager", { enumerable: true, get: function () { return CacheManager_1.CacheManager; } });
+var setupCache_1 = require("./core/cache/setupCache");
+Object.defineProperty(exports, "setupCache", { enumerable: true, get: function () { return setupCache_1.setupCache; } });
+var modelRegistration_1 = require("./core/orm/mixins/utils/modelRegistration");
+Object.defineProperty(exports, "registerModels", { enumerable: true, get: function () { return modelRegistration_1.registerModels; } });
+Object.defineProperty(exports, "isModelRegistered", { enumerable: true, get: function () { return modelRegistration_1.isModelRegistered; } });
+Object.defineProperty(exports, "setModelRegistryStrictMode", { enumerable: true, get: function () { return modelRegistration_1.setModelRegistryStrictMode; } });
+Object.defineProperty(exports, "isModelRegistryStrictMode", { enumerable: true, get: function () { return modelRegistration_1.isModelRegistryStrictMode; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA;;;;GAIG;AACH,oDAWgC;AAV9B,sGAAA,SAAS,OAAA;AACT,kGAAA,KAAK,OAAA;AACL,qGAAA,QAAQ,OAAA;AACR,uGAAA,UAAU,OAAA;AACV,0GAAA,aAAa,OAAA;AAQf,uEAAsE;AAA7D,oHAAA,gBAAgB,OAAA;AACzB,yDAKuC;AAJrC,kGAAA,OAAO,OAAA;AAMT,oDAGgC;AAF9B,sGAAA,SAAS,OAAA;AAIX,iEAgBuC;AAfrC,yGAAA,MAAM,OAAA;AACN,2GAAA,QAAQ,OAAA;AACR,2GAAA,QAAQ,OAAA;AACR,wGAAA,KAAK,OAAA;AACL,iHAAA,cAAc,OAAA;AAahB,iEAOuC;AANrC,kHAAA,eAAe,OAAA;AAQjB,6DAAoF;AAA3E,8GAAA,aAAa,OAAA;AAEtB,0DAAyD;AAAhD,4GAAA,YAAY,OAAA;AACrB,sDAAqD;AAA5C,wGAAA,UAAU,OAAA;AAEnB,+EAMmD;AALjD,mHAAA,cAAc,OAAA;AACd,sHAAA,iBAAiB,OAAA;AACjB,+HAAA,0BAA0B,OAAA;AAC1B,8HAAA,yBAAyB,OAAA"}

package/package.json

@@ -0,0 +1,104 @@
+{
+  "name": "@alpha.consultings/eloquent-orm.js",
+  "version": "1.0.1",
+  "description": "A Laravel Eloquent-inspired ORM Multi Driver SQL & NoSQL and Cache System and Artisan CLI like for Node.js Lovers",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": "20.x"
+  },
+  "docsSupportMatrix": {
+    "memcachedServer": "1.6+"
+  },
+  "type": "commonjs",
+  "author": {
+    "name": "MEKHERBECHE Fares",
+    "github": "https://github.com/MetalDz"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./Model": {
+      "types": "./dist/Model.d.ts",
+      "require": "./dist/Model.js",
+      "default": "./dist/Model.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "eloquent": "./dist/cli/eloquent.js"
+  },
+  "files": [
+    "dist",
+    "src/cli/templates/**/*",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "docs:sync-package-metadata": "node scripts/sync-package-metadata.cjs",
+    "docs:sync-supported": "node scripts/sync-supported-versions.cjs",
+    "docs:sync-config": "node scripts/sync-mintlify-configs.cjs",
+    "clean": "node -e \"require('fs').rmSync('dist', { recursive: true, force: true })\"",
+    "build": "npm run docs:sync-package-metadata && npm run docs:sync-supported && npm run clean && tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p . --noEmit --skipLibCheck",
+    "docs:dev": "npm run docs:sync-package-metadata && npm run docs:sync-config && node scripts/run-mintlify.cjs dev",
+    "docs:build": "npm run docs:sync-package-metadata && npm run docs:sync-supported && npm run docs:sync-config && node scripts/run-mintlify.cjs validate",
+    "docs:validate": "npm run docs:sync-package-metadata && npm run docs:sync-supported && npm run docs:sync-config && node scripts/run-mintlify.cjs validate",
+    "docs:lint": "npm run docs:sync-package-metadata && npm run docs:sync-supported && npm run docs:sync-config && node scripts/run-mintlify.cjs broken-links",
+    "test": "jest --runInBand",
+    "test:coverage": "jest --runInBand --coverage",
+    "test:mysql-smoke": "jest --runInBand --runTestsByPath src/lab_test/cli.integration.scenario.lifecycle.test.ts src/lab_test/cli.integration.make-migration.targeting.test.ts src/lab_test/cli.integration.migrate.targeting.test.ts src/lab_test/cli.integration.seed-and-demo.targeting.test.ts src/lab_test/cli.integration.factory-status.targeting.test.ts src/lab_test/migration.tracker.logic.test.ts src/lab_test/cache.commands.logic.test.ts",
+    "coverage:misses": "npm run test:coverage && node scripts/coverage-misses.cjs",
+    "test:critical": "jest --runInBand src/lab_test/cli.integration.scenario.lifecycle.test.ts src/lab_test/cli.integration.make-migration.targeting.test.ts src/lab_test/cli.integration.migrate.targeting.test.ts src/lab_test/cli.integration.seed-and-demo.targeting.test.ts src/lab_test/cli.integration.factory-status.targeting.test.ts src/lab_test/migration.tracker.logic.test.ts src/lab_test/cache.commands.logic.test.ts",
+    "test:pack-smoke": "node scripts/pack-smoke.js",
+    "test:pack-smoke:docker": "docker compose -f docker-compose.coverage-debug.yml run --rm pack-smoke",
+    "dev": "ts-node src/index.ts",
+    "cli": "ts-node bin/eloquent.ts",
+    "release": "npm run docs:sync-package-metadata && npm run docs:sync-supported && semantic-release"
+  },
+  "dependencies": {
+    "@faker-js/faker": "^10.1.0",
+    "better-sqlite3": "12.2.0",
+    "chalk": "^5.6.2",
+    "commander": "^12.1.0",
+    "dotenv": "^17.2.3",
+    "figlet": "^1.9.3",
+    "memcached": "^2.2.2",
+    "mongodb": "^6.20.0",
+    "mysql2": "^3.15.2",
+    "pg": "^8.16.3",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.38.0",
+    "@mintlify/cli": "^4.0.1049",
+    "@mintlify/validation": "^0.1.640",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/commit-analyzer": "^12.0.0",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^10.0.4",
+    "@semantic-release/npm": "^12.0.2",
+    "@semantic-release/release-notes-generator": "^13.0.0",
+    "@types/express": "^5.0.0",
+    "@types/figlet": "^1.7.0",
+    "@types/jest": "^30.0.0",
+    "@types/memcached": "^2.2.10",
+    "@types/node": "^22.18.12",
+    "@types/pg": "^8.15.5",
+    "eslint": "^9.38.0",
+    "express": "^5.1.0",
+    "jest": "^30.2.0",
+    "semantic-release": "^24.2.9",
+    "ts-jest": "^29.4.5",
+    "tsx": "^4.20.6",
+    "typescript-eslint": "^8.46.1",
+    "vitest": "^4.0.7"
+  }
+}

package/src/cli/templates/controller.tpl

@@ -0,0 +1,80 @@
+import type { Request, Response } from "express";
+import { {{PascalCase}}Service } from "{{serviceImportPath}}";
+
+export class {{PascalCase}}Controller {
+  private service = new {{PascalCase}}Service();
+
+  // GET /{{camelCase}}
+  async index(req: Request, res: Response): Promise<void> {
+    try {
+      const data = await this.service.all();
+      res.json(data);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      res.status(500).json({ error: message });
+    }
+  }
+
+  // GET /{{camelCase}}/:id
+  async show(req: Request, res: Response): Promise<void> {
+    try {
+      const id = req.params?.id as unknown as string | number | undefined;
+      const item = id ? await this.service.find(id) : null;
+      if (!item) {
+        res.status(404).json({ message: "{{PascalCase}} not found" });
+        return;
+      }
+      res.json(item);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      res.status(500).json({ error: message });
+    }
+  }
+
+  // POST /{{camelCase}}
+  async store(req: Request, res: Response): Promise<void> {
+    try {
+      const payload = req.body as Record<string, unknown>;
+      const created = await this.service.create(payload);
+      res.status(201).json(created);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      res.status(400).json({ error: message });
+    }
+  }
+
+  // PUT /{{camelCase}}/:id
+  async update(req: Request, res: Response): Promise<void> {
+    try {
+      const id = req.params?.id as unknown as string | number | undefined;
+      if (id === undefined) {
+        res.status(400).json({ error: "Missing id" });
+        return;
+      }
+      const payload = req.body as Record<string, unknown>;
+      await this.service.update(id, payload);
+      res.json({ message: "{{PascalCase}} updated successfully" });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      res.status(400).json({ error: message });
+    }
+  }
+
+  // DELETE /{{camelCase}}/:id
+  async destroy(req: Request, res: Response): Promise<void> {
+    try {
+      const id = req.params?.id as unknown as string | number | undefined;
+      if (id === undefined) {
+        res.status(400).json({ error: "Missing id" });
+        return;
+      }
+      await this.service.delete(id);
+      res.json({ message: "{{PascalCase}} deleted successfully" });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      res.status(400).json({ error: message });
+    }
+  }
+
+  {{softDeleteBlock}}
+}

package/src/cli/templates/factory.tpl

@@ -0,0 +1,14 @@
+import { Factory } from "{{packageImportPath}}";
+import { {{ModelName}} } from "../../models/{{ModelName}}";
+
+export class {{FactoryName}} extends Factory<{{ModelName}}> {
+  model = {{ModelName}};
+
+  definition(index = 0): Partial<{{ModelName}}> {
+    return {
+{{#each fields}}
+      {{name}}: this.faker.{{fakerPath}},
+{{/each}}
+    };
+  }
+}

package/src/cli/templates/migration.tpl

@@ -0,0 +1,36 @@
+/**
+ * Migration: {{name}}
+ * Generated by EloquentJS Artisan v2.0
+ * Date: {{date}}
+ */
+
+export async function up(db: DatabaseConnection) {
+  interface TableBuilder {
+    increments(column: string): this;
+    primary(): this;
+    string(column: string): this;
+    unique?(): this;
+    timestamp?(column: string): this;
+    timestamps?(useTz?: boolean, defaultNow?: boolean): this;
+  }
+
+  await db.schema.createTable<TableBuilder>("{{tableName}}", (table) => {
+    table.increments("id").primary();
+    table.string("name");
+    // Add more columns here.
+  });
+}
+
+export async function down(db: DatabaseConnection) {
+  await db.schema.dropTableIfExists("{{tableName}}");
+}
+
+interface SchemaBuilder {
+  createTable<T>(name: string, callback: (table: T) => void): Promise<void>;
+  dropTableIfExists(name: string): Promise<void>;
+}
+
+interface DatabaseConnection {
+  schema: SchemaBuilder;
+  fn: { now(): string | Date };
+}

package/src/cli/templates/model-registry.tpl

@@ -0,0 +1,16 @@
+import { registerModels, type RegisterModelsOptions } from "{{packageImportPath}}";
+{{#each models}}
+import { {{name}} } from "{{importPath}}";
+{{/each}}
+
+export const {{modelsConstName}} = [
+{{#each models}}
+  {{name}},
+{{/each}}
+] as const;
+
+export function {{functionName}}(
+  options: RegisterModelsOptions = {},
+): void {
+  registerModels([...{{modelsConstName}}], options);
+}

package/src/cli/templates/model.tpl

@@ -0,0 +1,95 @@
+import { {{modelBaseClass}}, ModelInstance } from "{{coreImportPath}}";
+import { column, validate } from "{{schemaImportPath}}";
+
+/**
+ * {{ModelName}} model
+ * Auto-generated by EloquentJS ORM.
+ * Table: {{tableName}}
+ * Connection: {{connectionDescription}}
+ */
+type {{ModelName}}Attrs = {
+{{attrsTypeBody}}
+};
+
+export class {{ModelName}} extends {{modelBaseClass}}<{{ModelName}}Attrs> {
+  static tableName = "{{tableName}}";
+  static connectionName = {{connectionExpression}};
+
+  // Used by morphTo/morphMany relations.
+  static morphAlias = "{{tableName}}";
+
+  static schema = {
+    id: column("increments", undefined, { primary: true }),
+    name: validate(column("string", 255), { required: true, min: 3 }),
+    created_at: column("timestamp"),
+    updated_at: column("timestamp"),
+
+    /*
+     * RELATIONS EXAMPLES (uncomment and adapt):
+     * user: { kind: "relation", relation: "belongsTo", model: "User", options: { foreignKey: "user_id" } },
+     * image: { kind: "relation", relation: "morphOne", model: "Image", options: { morphName: "imageable" } },
+     * comments: { kind: "relation", relation: "morphMany", model: "Comment", options: { morphName: "commentable" } },
+     * commentable: { kind: "relation", relation: "morphTo", options: { morphName: "commentable" } },
+     */
+  };
+
+  /*
+   * OPTIONAL MIXINS (uncomment as needed):
+   * static timestamps = true;
+   * static softDeletes = true;
+   * static cacheEnabled = true;
+   *
+   * INSTANCE PERSISTENCE EXAMPLES
+   * -------------------------------------------------
+   *   const model = new {{ModelName}}();
+   *   model.fill({ name: "Example" });
+   *   await model.save();
+   *   model.update({ name: "Example 2" });
+   *   await model.save();
+   *   await model.patch({ name: "Example 3" });
+   * -------------------------------------------------
+   */
+
+  static validationHooks = {
+    beforeValidate: async (data: Record<string, unknown>) => {
+      console.log("[beforeValidate] {{ModelName}}", data);
+    },
+    afterValidate: async (data: Record<string, unknown>) => {
+      console.log("[afterValidate] {{ModelName}}", data);
+    },
+  };
+
+  static customRules = {
+    isUnique: async (_value: unknown) => {
+      // Example: add uniqueness logic here.
+      return true;
+    },
+  };
+
+  static modelEvents = {
+    beforeCreate: async (data: Record<string, unknown>) => {
+      console.log("[beforeCreate] {{ModelName}}", data);
+    },
+    afterCreate: async (record: Record<string, unknown> | null) => {
+      console.log("[afterCreate] {{ModelName}} created:", record);
+    },
+    beforeUpdate: async (data: Record<string, unknown>) => {
+      console.log("[beforeUpdate] {{ModelName}}", data);
+    },
+    afterUpdate: async (data: Record<string, unknown>) => {
+      console.log("[afterUpdate] {{ModelName}} updated:", data);
+    },
+    beforeDelete: async (id: number | string) => {
+      console.log("[beforeDelete] {{ModelName}}", id);
+    },
+    afterDelete: async (id: number | string) => {
+      console.log("[afterDelete] {{ModelName}}", id);
+    },
+  };
+
+  constructor() {
+    super("{{tableName}}", {{connectionExpression}});
+  }
+}
+
+export interface {{ModelName}} extends ModelInstance<{{ModelName}}Attrs> {}

package/src/cli/templates/pivot-factory.tpl

@@ -0,0 +1,85 @@
+import { BaseModel, Factory, PivotHelperMixin } from "{{packageImportPath}}";
+
+class PivotModelBase extends BaseModel {}
+const PivotModel = PivotHelperMixin(PivotModelBase);
+
+/**
+ * Auto-generated pivot factory for many-to-many operations.
+ * Table: {{pivotTable}}
+ */
+export class {{PivotFactoryName}} extends Factory<BaseModel> {
+  readonly model = PivotModel;
+
+  definition(): Partial<Record<string, unknown>> {
+    return {
+      {{foreignKey}}: null,
+      {{relatedKey}}: null,
+    };
+  }
+
+  async createPivot(
+    foreignId: string | number,
+    relatedIds: Iterable<string | number>,
+    extraPivotAttrs?: Record<string, unknown>
+  ): Promise<void> {
+    type PivotInstanceLike = {
+      attach?: (
+        pivotTable: string,
+        foreignKey: string,
+        relatedKey: string,
+        foreignId: string | number,
+        relatedIds: Array<string | number>,
+        extra?: Record<string, unknown>
+      ) => Promise<void>;
+      attachMany?: (entries: Array<Record<string, unknown>>) => Promise<void>;
+      withTransaction?: <R>(fn: () => Promise<R>) => Promise<R>;
+    };
+
+    const PivotCtor = this.model as unknown as new () => PivotInstanceLike;
+    const pivotInstance = new PivotCtor();
+    const relatedArray = Array.from(relatedIds);
+
+    try {
+      if (typeof pivotInstance.attachMany === "function") {
+        const entries = relatedArray.map((rid) => ({
+          ["{{foreignKey}}"]: foreignId,
+          ["{{relatedKey}}"]: rid,
+          ...(extraPivotAttrs ?? {}),
+        }));
+        await pivotInstance.attachMany(entries);
+      } else if (typeof pivotInstance.attach === "function") {
+        const attach = pivotInstance.attach.bind(pivotInstance);
+        if (typeof pivotInstance.withTransaction === "function") {
+          await pivotInstance.withTransaction(async () => {
+            await attach(
+              "{{pivotTable}}",
+              "{{foreignKey}}",
+              "{{relatedKey}}",
+              foreignId,
+              relatedArray,
+              extraPivotAttrs
+            );
+          });
+        } else {
+          await attach(
+            "{{pivotTable}}",
+            "{{foreignKey}}",
+            "{{relatedKey}}",
+            foreignId,
+            relatedArray,
+            extraPivotAttrs
+          );
+        }
+      } else {
+        throw new Error("PivotHelperMixin does not expose attach/attachMany API.");
+      }
+    } catch (err) {
+      // eslint-disable-next-line no-console
+      console.error(
+        `[pivot-factory] Failed to attach pivot rows for ${foreignId} -> ${relatedArray}:`,
+        err
+      );
+      throw err;
+    }
+  }
+}

package/src/cli/templates/seed.tpl

@@ -0,0 +1,20 @@
+/**
+ * Auto-generated seeder
+ * Seeder: {{SeederName}}
+ * Linked model: {{ModelName}}
+ * Created at: {{Timestamp}}
+ */
+
+import { {{FactoryName}} } from "../factories/{{FactoryName}}";
+
+export async function {{SeederName}}() {
+  console.log("Running seeder: {{SeederName}}");
+
+  const factory = new {{FactoryName}}();
+
+  await factory.createMany({{Count}}, (instance, i) => {
+    console.log(`Created #${i + 1}:`, instance);
+  });
+
+  console.log("Seeding completed for {{ModelName}}");
+}

package/src/cli/templates/service.tpl

@@ -0,0 +1,40 @@
+import { {{ModelName}} } from "{{modelImportPath}}";
+
+export class {{ModelName}}Service {
+  async all() {
+    return new {{ModelName}}().all();
+  }
+
+  async find(id: number | string) {
+    return {{ModelName}}.find(id);
+  }
+
+  async create(data: Record<string, unknown>) {
+    return {{ModelName}}.create(data);
+  }
+
+  async createMany(rows: Record<string, unknown>[]) {
+    return {{ModelName}}.createMany(rows);
+  }
+
+  async update(id: number | string, data: Record<string, unknown>) {
+    const model = await {{ModelName}}.find(id);
+    if (!model) return null;
+
+    model.update(data);
+    await model.save();
+    return model;
+  }
+
+  async delete(id: number | string) {
+    return {{ModelName}}.deleteById(id);
+  }
+
+  async restore(id: number | string) {
+    return {{ModelName}}.restoreById(id);
+  }
+
+  async updateMany(ids: Array<number | string>, data: Record<string, unknown>) {
+    return {{ModelName}}.updateMany(ids, data);
+  }
+}