@meridianjs/framework 0.1.1 → 0.1.3

package/dist/index.js

@@ -138,9 +138,9 @@ async function resolveModuleDefinition(config, rootDir) {
 }
 
 // src/plugin-loader.ts
-import path6 from "path";
-import fs4 from "fs/promises";
-import { pathToFileURL as pathToFileURL6 } from "url";
+import path7 from "path";
+import fs5 from "fs/promises";
+import { pathToFileURL as pathToFileURL7 } from "url";
 import { createRequire } from "module";
 
 // src/route-loader.ts
@@ -316,13 +316,94 @@ async function loadJobs(container, jobsDir) {
   }
 }
 
+// src/link-loader.ts
+import fs4 from "fs/promises";
+import path6 from "path";
+import { pathToFileURL as pathToFileURL6 } from "url";
+async function loadLinks(container, linksDir) {
+  const logger = container.resolve("logger");
+  const definitions = [];
+  try {
+    await fs4.access(linksDir);
+  } catch {
+    logger.debug(`No links directory at ${linksDir}, skipping.`);
+    registerEmptyServices(container);
+    return;
+  }
+  const files = await fs4.readdir(linksDir);
+  for (const file of files) {
+    if (!/\.(ts|mts|js|mjs|cjs)$/.test(file)) continue;
+    const fullPath = path6.join(linksDir, file);
+    let mod;
+    try {
+      mod = await import(pathToFileURL6(fullPath).href);
+    } catch (err) {
+      logger.error(`Failed to load link file ${file}: ${err.message}`);
+      continue;
+    }
+    const def = mod.default;
+    if (def?.linkTableName) {
+      definitions.push(def);
+      logger.debug(`Link loaded: ${def.linkTableName}`);
+    }
+  }
+  let existingDefs = [];
+  try {
+    const existingLink = container.resolve("link");
+    existingDefs = existingLink.getDefinitions?.() ?? [];
+  } catch {
+  }
+  const allDefs = [...existingDefs, ...definitions];
+  const linkService = new LinkService(allDefs, container, logger);
+  const queryService = new QueryService(allDefs, container, logger);
+  container.register({
+    link: linkService,
+    query: queryService
+  });
+  logger.info(`Loaded ${allDefs.length} module link(s)`);
+}
+function registerEmptyServices(container) {
+  const link = new LinkService([], container, null);
+  const query = new QueryService([], container, null);
+  container.register({ link, query });
+}
+var LinkService = class {
+  constructor(defs, container, logger) {
+    this.defs = defs;
+    this.container = container;
+    this.logger = logger;
+    this.defsByTable = new Map(defs.map((d) => [d.linkTableName, d]));
+  }
+  defsByTable;
+  async create(linkTableName, leftId, rightId, data) {
+    this.logger?.debug(`Link.create: ${linkTableName} ${leftId} \u2192 ${rightId}`);
+  }
+  async dismiss(linkTableName, leftId, rightId) {
+    this.logger?.debug(`Link.dismiss: ${linkTableName} ${leftId} \u2192 ${rightId}`);
+  }
+  getDefinitions() {
+    return this.defs;
+  }
+};
+var QueryService = class {
+  constructor(defs, container, logger) {
+    this.defs = defs;
+    this.container = container;
+    this.logger = logger;
+  }
+  async graph(options) {
+    this.logger?.debug(`Query.graph: ${options.entity}`, { fields: options.fields });
+    return { data: [] };
+  }
+};
+
 // src/plugin-loader.ts
 async function loadPlugins(container, plugins, rootDir) {
   const logger = container.resolve("logger");
   for (const plugin of plugins) {
     logger.info(`Loading plugin: ${plugin.resolve}`);
-    const isLocalPath = plugin.resolve.startsWith(".") || path6.isAbsolute(plugin.resolve);
-    const importPath = isLocalPath ? pathToFileURL6(path6.resolve(rootDir, plugin.resolve)).href : plugin.resolve;
+    const isLocalPath = plugin.resolve.startsWith(".") || path7.isAbsolute(plugin.resolve);
+    const importPath = isLocalPath ? pathToFileURL7(path7.resolve(rootDir, plugin.resolve)).href : plugin.resolve;
     let pluginMod;
     try {
       pluginMod = await import(importPath);
@@ -334,12 +415,12 @@ async function loadPlugins(container, plugins, rootDir) {
     if (pluginMod.pluginRoot && typeof pluginMod.pluginRoot === "string") {
       scanRoot = pluginMod.pluginRoot;
     } else if (isLocalPath) {
-      const resolvedPath = path6.resolve(rootDir, plugin.resolve);
+      const resolvedPath = path7.resolve(rootDir, plugin.resolve);
       try {
-        const stat = await fs4.stat(resolvedPath);
-        scanRoot = stat.isDirectory() ? resolvedPath : path6.dirname(resolvedPath);
+        const stat = await fs5.stat(resolvedPath);
+        scanRoot = stat.isDirectory() ? resolvedPath : path7.dirname(resolvedPath);
       } catch {
-        scanRoot = path6.dirname(resolvedPath);
+        scanRoot = path7.dirname(resolvedPath);
       }
     } else {
       scanRoot = resolveNpmPackageRoot(plugin.resolve, rootDir);
@@ -366,23 +447,28 @@ async function loadPlugins(container, plugins, rootDir) {
   }
 }
 async function autoScanPlugin(scanRoot, container, logger) {
-  const server = container.resolve("server");
+  let server = null;
+  try {
+    server = container.resolve("server");
+  } catch {
+  }
   const candidates = [
     scanRoot,
     // pluginRoot already points to compiled dir
-    path6.join(scanRoot, "dist"),
+    path7.join(scanRoot, "dist"),
     // package root → try dist/ first
-    path6.join(scanRoot, "src")
+    path7.join(scanRoot, "src")
     // package root → try src/ (tsx dev mode)
   ];
   for (const candidate of candidates) {
-    const apiDir = path6.join(candidate, "api");
+    const apiDir = path7.join(candidate, "api");
     try {
-      await fs4.access(apiDir);
+      await fs5.access(apiDir);
       await Promise.all([
-        loadRoutes(server, container, apiDir),
-        loadSubscribers(container, path6.join(candidate, "subscribers")),
-        loadJobs(container, path6.join(candidate, "jobs"))
+        server ? loadRoutes(server, container, apiDir) : Promise.resolve(),
+        loadSubscribers(container, path7.join(candidate, "subscribers")),
+        loadJobs(container, path7.join(candidate, "jobs")),
+        loadLinks(container, path7.join(candidate, "links"))
       ]);
       logger.debug(`Plugin auto-scanned from: ${candidate}`);
       return;
@@ -393,20 +479,20 @@ async function autoScanPlugin(scanRoot, container, logger) {
 }
 function resolveNpmPackageRoot(packageName, fromDir) {
   try {
-    const require2 = createRequire(path6.join(fromDir, "synthetic.cjs"));
+    const require2 = createRequire(path7.join(fromDir, "synthetic.cjs"));
     const pkgJsonPath = require2.resolve(`${packageName}/package.json`);
-    return path6.dirname(pkgJsonPath);
+    return path7.dirname(pkgJsonPath);
   } catch {
     try {
-      const require2 = createRequire(path6.join(fromDir, "synthetic.cjs"));
+      const require2 = createRequire(path7.join(fromDir, "synthetic.cjs"));
       const mainPath = require2.resolve(packageName);
-      let dir = path6.dirname(mainPath);
-      while (dir !== path6.dirname(dir)) {
+      let dir = path7.dirname(mainPath);
+      while (dir !== path7.dirname(dir)) {
         try {
-          require2.resolve(path6.join(dir, "package.json"));
+          require2.resolve(path7.join(dir, "package.json"));
           return dir;
         } catch {
-          dir = path6.dirname(dir);
+          dir = path7.dirname(dir);
         }
       }
     } catch {
@@ -415,80 +501,6 @@ function resolveNpmPackageRoot(packageName, fromDir) {
   }
 }
 
-// src/link-loader.ts
-import fs5 from "fs/promises";
-import path7 from "path";
-import { pathToFileURL as pathToFileURL7 } from "url";
-async function loadLinks(container, linksDir) {
-  const logger = container.resolve("logger");
-  const definitions = [];
-  try {
-    await fs5.access(linksDir);
-  } catch {
-    logger.debug(`No links directory at ${linksDir}, skipping.`);
-    registerEmptyServices(container);
-    return;
-  }
-  const files = await fs5.readdir(linksDir);
-  for (const file of files) {
-    if (!/\.(ts|mts|js|mjs|cjs)$/.test(file)) continue;
-    const fullPath = path7.join(linksDir, file);
-    let mod;
-    try {
-      mod = await import(pathToFileURL7(fullPath).href);
-    } catch (err) {
-      logger.error(`Failed to load link file ${file}: ${err.message}`);
-      continue;
-    }
-    const def = mod.default;
-    if (def?.linkTableName) {
-      definitions.push(def);
-      logger.debug(`Link loaded: ${def.linkTableName}`);
-    }
-  }
-  const linkService = new LinkService(definitions, container, logger);
-  const queryService = new QueryService(definitions, container, logger);
-  container.register({
-    link: linkService,
-    query: queryService
-  });
-  logger.info(`Loaded ${definitions.length} module link(s)`);
-}
-function registerEmptyServices(container) {
-  const link = new LinkService([], container, null);
-  const query = new QueryService([], container, null);
-  container.register({ link, query });
-}
-var LinkService = class {
-  constructor(defs, container, logger) {
-    this.defs = defs;
-    this.container = container;
-    this.logger = logger;
-    this.defsByTable = new Map(defs.map((d) => [d.linkTableName, d]));
-  }
-  defsByTable;
-  async create(linkTableName, leftId, rightId, data) {
-    this.logger?.debug(`Link.create: ${linkTableName} ${leftId} \u2192 ${rightId}`);
-  }
-  async dismiss(linkTableName, leftId, rightId) {
-    this.logger?.debug(`Link.dismiss: ${linkTableName} ${leftId} \u2192 ${rightId}`);
-  }
-  getDefinitions() {
-    return this.defs;
-  }
-};
-var QueryService = class {
-  constructor(defs, container, logger) {
-    this.defs = defs;
-    this.container = container;
-    this.logger = logger;
-  }
-  async graph(options) {
-    this.logger?.debug(`Query.graph: ${options.entity}`, { fields: options.fields });
-    return { data: [] };
-  }
-};
-
 // src/server.ts
 import express from "express";
 import cors from "cors";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meridianjs/framework",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Core Meridian framework: bootstrap, DI container, module/route/subscriber/job loaders",
   "main": "./dist/index.js",
   "module": "./dist/index.js",