@objectstack/plugin-dev 2.0.6

package/dist/index.js

@@ -0,0 +1,735 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DevPlugin: () => DevPlugin
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/dev-plugin.ts
+var CORE_SERVICE_NAMES = [
+  "metadata",
+  "data",
+  "auth",
+  "file-storage",
+  "search",
+  "cache",
+  "queue",
+  "automation",
+  "graphql",
+  "analytics",
+  "realtime",
+  "job",
+  "notification",
+  "ai",
+  "i18n",
+  "ui",
+  "workflow"
+];
+var SECURITY_SERVICE_NAMES = [
+  "security.permissions",
+  "security.rls",
+  "security.fieldMasker"
+];
+function createCacheStub() {
+  const store = /* @__PURE__ */ new Map();
+  let hits = 0;
+  let misses = 0;
+  return {
+    _dev: true,
+    _serviceName: "cache",
+    async get(key) {
+      const entry = store.get(key);
+      if (!entry || entry.expires && Date.now() > entry.expires) {
+        store.delete(key);
+        misses++;
+        return void 0;
+      }
+      hits++;
+      return entry.value;
+    },
+    async set(key, value, ttl) {
+      store.set(key, { value, expires: ttl ? Date.now() + ttl * 1e3 : void 0 });
+    },
+    async delete(key) {
+      return store.delete(key);
+    },
+    async has(key) {
+      return store.has(key);
+    },
+    async clear() {
+      store.clear();
+    },
+    async stats() {
+      return { hits, misses, keyCount: store.size };
+    }
+  };
+}
+function createQueueStub() {
+  const handlers = /* @__PURE__ */ new Map();
+  let msgId = 0;
+  return {
+    _dev: true,
+    _serviceName: "queue",
+    async publish(queue, data) {
+      const id = `dev-msg-${++msgId}`;
+      const fns = handlers.get(queue) ?? [];
+      for (const fn of fns) fn({ id, data, attempts: 1, timestamp: Date.now() });
+      return id;
+    },
+    async subscribe(queue, handler) {
+      handlers.set(queue, [...handlers.get(queue) ?? [], handler]);
+    },
+    async unsubscribe(queue) {
+      handlers.delete(queue);
+    },
+    async getQueueSize() {
+      return 0;
+    },
+    async purge(queue) {
+      handlers.delete(queue);
+    }
+  };
+}
+function createJobStub() {
+  const jobs = /* @__PURE__ */ new Map();
+  return {
+    _dev: true,
+    _serviceName: "job",
+    async schedule(name, schedule, handler) {
+      jobs.set(name, { schedule, handler });
+    },
+    async cancel(name) {
+      jobs.delete(name);
+    },
+    async trigger(name, data) {
+      const job = jobs.get(name);
+      if (job?.handler) await job.handler({ jobId: name, data });
+    },
+    async getExecutions() {
+      return [];
+    },
+    async listJobs() {
+      return [...jobs.keys()];
+    }
+  };
+}
+function createStorageStub() {
+  const files = /* @__PURE__ */ new Map();
+  return {
+    _dev: true,
+    _serviceName: "file-storage",
+    async upload(key, data, options) {
+      files.set(key, { data: Buffer.from(data), meta: { contentType: options?.contentType, metadata: options?.metadata } });
+    },
+    async download(key) {
+      return files.get(key)?.data ?? Buffer.alloc(0);
+    },
+    async delete(key) {
+      files.delete(key);
+    },
+    async exists(key) {
+      return files.has(key);
+    },
+    async getInfo(key) {
+      const f = files.get(key);
+      return { key, size: f?.data?.length ?? 0, contentType: f?.meta?.contentType, lastModified: /* @__PURE__ */ new Date(), metadata: f?.meta?.metadata };
+    },
+    async list(prefix) {
+      return [...files.entries()].filter(([k]) => k.startsWith(prefix)).map(([key, f]) => ({ key, size: f.data.length, contentType: f.meta?.contentType, lastModified: /* @__PURE__ */ new Date() }));
+    }
+  };
+}
+function createSearchStub() {
+  const indexes = /* @__PURE__ */ new Map();
+  return {
+    _dev: true,
+    _serviceName: "search",
+    async index(object, id, document) {
+      if (!indexes.has(object)) indexes.set(object, /* @__PURE__ */ new Map());
+      indexes.get(object).set(id, document);
+    },
+    async remove(object, id) {
+      indexes.get(object)?.delete(id);
+    },
+    async search(object, query) {
+      const docs = indexes.get(object) ?? /* @__PURE__ */ new Map();
+      const q = query.toLowerCase();
+      const hits = [...docs.entries()].filter(([, doc]) => JSON.stringify(doc).toLowerCase().includes(q)).map(([id, doc]) => ({ id, score: 1, document: doc }));
+      return { hits, totalHits: hits.length, processingTimeMs: 0 };
+    },
+    async bulkIndex(object, documents) {
+      if (!indexes.has(object)) indexes.set(object, /* @__PURE__ */ new Map());
+      for (const d of documents) {
+        indexes.get(object).set(d.id, d.document);
+      }
+    },
+    async deleteIndex(object) {
+      indexes.delete(object);
+    }
+  };
+}
+function createAutomationStub() {
+  const flows = /* @__PURE__ */ new Map();
+  return {
+    _dev: true,
+    _serviceName: "automation",
+    async execute(_flowName) {
+      return { success: true, output: void 0, durationMs: 0 };
+    },
+    async listFlows() {
+      return [...flows.keys()];
+    },
+    registerFlow(name, definition) {
+      flows.set(name, definition);
+    },
+    unregisterFlow(name) {
+      flows.delete(name);
+    }
+  };
+}
+function createGraphQLStub() {
+  return {
+    _dev: true,
+    _serviceName: "graphql",
+    async execute() {
+      return { data: null, errors: [{ message: "GraphQL not available in dev stub mode" }] };
+    },
+    getSchema() {
+      return "type Query { _dev: Boolean }";
+    }
+  };
+}
+function createAnalyticsStub() {
+  return {
+    _dev: true,
+    _serviceName: "analytics",
+    async query() {
+      return { rows: [], fields: [] };
+    },
+    async getMeta() {
+      return [];
+    },
+    async generateSql() {
+      return { sql: "", params: [] };
+    }
+  };
+}
+function createRealtimeStub() {
+  const subs = /* @__PURE__ */ new Map();
+  let subId = 0;
+  return {
+    _dev: true,
+    _serviceName: "realtime",
+    async publish(event) {
+      for (const fn of subs.values()) fn(event);
+    },
+    async subscribe(_channel, handler) {
+      const id = `dev-sub-${++subId}`;
+      subs.set(id, handler);
+      return id;
+    },
+    async unsubscribe(subscriptionId) {
+      subs.delete(subscriptionId);
+    }
+  };
+}
+function createNotificationStub() {
+  const sent = [];
+  return {
+    _dev: true,
+    _serviceName: "notification",
+    async send(message) {
+      sent.push(message);
+      return { success: true, messageId: `dev-notif-${sent.length}` };
+    },
+    async sendBatch(messages) {
+      return messages.map((m) => {
+        sent.push(m);
+        return { success: true, messageId: `dev-notif-${sent.length}` };
+      });
+    },
+    getChannels() {
+      return ["email", "in-app"];
+    }
+  };
+}
+function createAIStub() {
+  return {
+    _dev: true,
+    _serviceName: "ai",
+    async chat() {
+      return { content: "[dev-stub] AI not available in development mode", model: "dev-stub" };
+    },
+    async complete() {
+      return { content: "[dev-stub] AI not available in development mode", model: "dev-stub" };
+    },
+    async embed() {
+      return [[0]];
+    },
+    async listModels() {
+      return ["dev-stub"];
+    }
+  };
+}
+function createI18nStub() {
+  const translations = /* @__PURE__ */ new Map();
+  let defaultLocale = "en";
+  return {
+    _dev: true,
+    _serviceName: "i18n",
+    t(key, locale, params) {
+      const t = translations.get(locale);
+      const val = t?.[key];
+      if (typeof val === "string") {
+        return params ? val.replace(/\{\{(\w+)\}\}/g, (_, k) => String(params[k] ?? `{{${k}}}`)) : val;
+      }
+      return key;
+    },
+    getTranslations(locale) {
+      return translations.get(locale) ?? {};
+    },
+    loadTranslations(locale, data) {
+      translations.set(locale, { ...translations.get(locale), ...data });
+    },
+    getLocales() {
+      return [...translations.keys()];
+    },
+    getDefaultLocale() {
+      return defaultLocale;
+    },
+    setDefaultLocale(locale) {
+      defaultLocale = locale;
+    }
+  };
+}
+function createUIStub() {
+  const views = /* @__PURE__ */ new Map();
+  const dashboards = /* @__PURE__ */ new Map();
+  return {
+    _dev: true,
+    _serviceName: "ui",
+    getView(name) {
+      return views.get(name);
+    },
+    listViews(object) {
+      const all = [...views.values()];
+      return object ? all.filter((v) => v.object === object) : all;
+    },
+    getDashboard(name) {
+      return dashboards.get(name);
+    },
+    listDashboards() {
+      return [...dashboards.values()];
+    },
+    registerView(name, definition) {
+      views.set(name, definition);
+    },
+    registerDashboard(name, definition) {
+      dashboards.set(name, definition);
+    }
+  };
+}
+function createWorkflowStub() {
+  const states = /* @__PURE__ */ new Map();
+  const key = (obj, id) => `${obj}:${id}`;
+  return {
+    _dev: true,
+    _serviceName: "workflow",
+    async transition(t) {
+      states.set(key(t.object, t.recordId), t.targetState);
+      return { success: true, currentState: t.targetState };
+    },
+    async getStatus(object, recordId) {
+      return { recordId, object, currentState: states.get(key(object, recordId)) ?? "draft", availableTransitions: [] };
+    },
+    async getHistory() {
+      return [];
+    }
+  };
+}
+function createMetadataStub() {
+  const store = /* @__PURE__ */ new Map();
+  return {
+    _dev: true,
+    _serviceName: "metadata",
+    register(type, definition) {
+      if (!store.has(type)) store.set(type, /* @__PURE__ */ new Map());
+      store.get(type).set(definition.name ?? "", definition);
+    },
+    get(type, name) {
+      return store.get(type)?.get(name);
+    },
+    list(type) {
+      return [...store.get(type)?.values() ?? []];
+    },
+    unregister(type, name) {
+      store.get(type)?.delete(name);
+    },
+    getObject(name) {
+      return store.get("object")?.get(name);
+    },
+    listObjects() {
+      return [...store.get("object")?.values() ?? []];
+    },
+    unregisterPackage() {
+    }
+  };
+}
+function createAuthStub() {
+  return {
+    _dev: true,
+    _serviceName: "auth",
+    async handleRequest() {
+      return new Response(JSON.stringify({ success: true }), { status: 200 });
+    },
+    async verify() {
+      return { success: true, user: { id: "dev-admin", email: "admin@dev.local", name: "Admin", roles: ["admin"] } };
+    },
+    async logout() {
+    },
+    async getCurrentUser() {
+      return { id: "dev-admin", email: "admin@dev.local", name: "Admin", roles: ["admin"] };
+    }
+  };
+}
+function createDataStub() {
+  return {
+    _dev: true,
+    _serviceName: "data",
+    async find() {
+      return [];
+    },
+    async findOne() {
+      return void 0;
+    },
+    async insert(_obj, params) {
+      return { id: `dev-${Date.now()}`, ...params?.data };
+    },
+    async update(_obj, _id, params) {
+      return params?.data ?? {};
+    },
+    async delete() {
+      return true;
+    },
+    async count() {
+      return 0;
+    },
+    async aggregate() {
+      return [];
+    }
+  };
+}
+function createSecurityPermissionsStub() {
+  return {
+    _dev: true,
+    _serviceName: "security.permissions",
+    resolvePermissionSets() {
+      return [];
+    },
+    checkObjectPermission() {
+      return true;
+    },
+    getFieldPermissions() {
+      return {};
+    }
+  };
+}
+function createSecurityRLSStub() {
+  return {
+    _dev: true,
+    _serviceName: "security.rls",
+    compileFilter() {
+      return null;
+    },
+    getApplicablePolicies() {
+      return [];
+    }
+  };
+}
+function createSecurityFieldMaskerStub() {
+  return {
+    _dev: true,
+    _serviceName: "security.fieldMasker",
+    maskResults(results) {
+      return results;
+    }
+  };
+}
+var DEV_STUB_FACTORIES = {
+  "cache": createCacheStub,
+  "queue": createQueueStub,
+  "job": createJobStub,
+  "file-storage": createStorageStub,
+  "search": createSearchStub,
+  "automation": createAutomationStub,
+  "graphql": createGraphQLStub,
+  "analytics": createAnalyticsStub,
+  "realtime": createRealtimeStub,
+  "notification": createNotificationStub,
+  "ai": createAIStub,
+  "i18n": createI18nStub,
+  "ui": createUIStub,
+  "workflow": createWorkflowStub,
+  "metadata": createMetadataStub,
+  "data": createDataStub,
+  "auth": createAuthStub,
+  // Security sub-services
+  "security.permissions": createSecurityPermissionsStub,
+  "security.rls": createSecurityRLSStub,
+  "security.fieldMasker": createSecurityFieldMaskerStub
+};
+var DevPlugin = class {
+  constructor(options = {}) {
+    this.name = "com.objectstack.plugin.dev";
+    this.type = "standard";
+    this.version = "1.0.0";
+    this.childPlugins = [];
+    this.options = {
+      port: 3e3,
+      seedAdminUser: true,
+      authSecret: "objectstack-dev-secret-DO-NOT-USE-IN-PRODUCTION!!",
+      verbose: true,
+      ...options,
+      authBaseUrl: options.authBaseUrl ?? `http://localhost:${options.port ?? 3e3}`
+    };
+  }
+  /**
+   * Init Phase
+   *
+   * Dynamically imports and instantiates all core plugins.
+   * Uses dynamic imports so that peer dependencies remain optional —
+   * if a package isn't installed the service is silently skipped.
+   */
+  async init(ctx) {
+    ctx.logger.info("\u{1F680} DevPlugin initializing \u2014 auto-configuring all services for development");
+    const enabled = (name) => this.options.services?.[name] !== false;
+    if (enabled("objectql")) {
+      try {
+        const { ObjectQLPlugin } = await import("@objectstack/objectql");
+        const qlPlugin = new ObjectQLPlugin();
+        this.childPlugins.push(qlPlugin);
+        ctx.logger.info("  \u2714 ObjectQL engine enabled (data + metadata)");
+      } catch {
+        ctx.logger.warn("  \u2718 @objectstack/objectql not installed \u2014 skipping data engine");
+      }
+    }
+    if (enabled("driver")) {
+      try {
+        const { DriverPlugin } = await import("@objectstack/runtime");
+        const { InMemoryDriver } = await import("@objectstack/driver-memory");
+        const driver = new InMemoryDriver();
+        const driverPlugin = new DriverPlugin(driver, "memory");
+        this.childPlugins.push(driverPlugin);
+        ctx.logger.info("  \u2714 InMemoryDriver enabled");
+      } catch {
+        ctx.logger.warn("  \u2718 @objectstack/runtime or @objectstack/driver-memory not installed \u2014 skipping driver");
+      }
+    }
+    if (this.options.stack) {
+      try {
+        const { AppPlugin } = await import("@objectstack/runtime");
+        const appPlugin = new AppPlugin(this.options.stack);
+        this.childPlugins.push(appPlugin);
+        ctx.logger.info("  \u2714 App metadata loaded from stack definition");
+      } catch {
+        ctx.logger.warn("  \u2718 @objectstack/runtime not installed \u2014 skipping app metadata");
+      }
+    }
+    if (enabled("auth")) {
+      try {
+        const { AuthPlugin } = await import("@objectstack/plugin-auth");
+        const authPlugin = new AuthPlugin({
+          secret: this.options.authSecret,
+          baseUrl: this.options.authBaseUrl
+        });
+        this.childPlugins.push(authPlugin);
+        ctx.logger.info("  \u2714 Auth plugin enabled (dev credentials)");
+      } catch {
+        ctx.logger.warn("  \u2718 @objectstack/plugin-auth not installed \u2014 skipping auth");
+      }
+    }
+    if (enabled("security")) {
+      try {
+        const { SecurityPlugin } = await import("@objectstack/plugin-security");
+        const securityPlugin = new SecurityPlugin();
+        this.childPlugins.push(securityPlugin);
+        ctx.logger.info("  \u2714 Security plugin enabled (RBAC, RLS, field masking)");
+      } catch {
+        ctx.logger.debug("  \u2139 @objectstack/plugin-security not installed \u2014 skipping security");
+      }
+    }
+    if (enabled("server")) {
+      try {
+        const { HonoServerPlugin } = await import("@objectstack/plugin-hono-server");
+        const serverPlugin = new HonoServerPlugin({
+          port: this.options.port
+        });
+        this.childPlugins.push(serverPlugin);
+        ctx.logger.info(`  \u2714 Hono HTTP server enabled on port ${this.options.port}`);
+      } catch {
+        ctx.logger.warn("  \u2718 @objectstack/plugin-hono-server not installed \u2014 skipping HTTP server");
+      }
+    }
+    if (enabled("rest")) {
+      try {
+        const { createRestApiPlugin } = await import("@objectstack/rest");
+        const restPlugin = createRestApiPlugin();
+        this.childPlugins.push(restPlugin);
+        ctx.logger.info("  \u2714 REST API endpoints enabled (CRUD + metadata)");
+      } catch {
+        ctx.logger.debug("  \u2139 @objectstack/rest not installed \u2014 skipping REST endpoints");
+      }
+    }
+    if (enabled("dispatcher")) {
+      try {
+        const { createDispatcherPlugin } = await import("@objectstack/runtime");
+        const dispatcherPlugin = createDispatcherPlugin();
+        this.childPlugins.push(dispatcherPlugin);
+        ctx.logger.info("  \u2714 Dispatcher enabled (auth, GraphQL, analytics, packages, storage)");
+      } catch {
+        ctx.logger.debug("  \u2139 Dispatcher not available \u2014 skipping extended API routes");
+      }
+    }
+    if (this.options.extraPlugins) {
+      this.childPlugins.push(...this.options.extraPlugins);
+    }
+    for (const plugin of this.childPlugins) {
+      try {
+        await plugin.init(ctx);
+      } catch (err) {
+        ctx.logger.error(`Failed to init child plugin ${plugin.name}: ${err.message}`);
+      }
+    }
+    const stubNames = [];
+    for (const svc of CORE_SERVICE_NAMES) {
+      if (!enabled(svc)) continue;
+      try {
+        ctx.getService(svc);
+      } catch {
+        const factory = DEV_STUB_FACTORIES[svc];
+        ctx.registerService(svc, factory ? factory() : { _dev: true, _serviceName: svc });
+        stubNames.push(svc);
+      }
+    }
+    if (enabled("security")) {
+      for (const svc of SECURITY_SERVICE_NAMES) {
+        try {
+          ctx.getService(svc);
+        } catch {
+          const factory = DEV_STUB_FACTORIES[svc];
+          ctx.registerService(svc, factory ? factory() : { _dev: true, _serviceName: svc });
+          stubNames.push(svc);
+        }
+      }
+    }
+    if (stubNames.length > 0) {
+      ctx.logger.info(`  \u2714 Contract-compliant dev stubs registered for: ${stubNames.join(", ")}`);
+    }
+    ctx.logger.info(`DevPlugin initialized ${this.childPlugins.length} plugin(s) + ${stubNames.length} dev stub(s)`);
+  }
+  /**
+   * Start Phase
+   *
+   * Starts all child plugins and optionally seeds the dev admin user.
+   */
+  async start(ctx) {
+    for (const plugin of this.childPlugins) {
+      if (plugin.start) {
+        try {
+          await plugin.start(ctx);
+        } catch (err) {
+          ctx.logger.error(`Failed to start child plugin ${plugin.name}: ${err.message}`);
+        }
+      }
+    }
+    if (this.options.seedAdminUser) {
+      await this.seedAdmin(ctx);
+    }
+    ctx.logger.info("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    ctx.logger.info("\u{1F7E2} ObjectStack Dev Server ready");
+    ctx.logger.info(`   http://localhost:${this.options.port}`);
+    ctx.logger.info("");
+    ctx.logger.info("   API:       /api/v1/data/:object");
+    ctx.logger.info("   Metadata:  /api/v1/meta/:type/:name");
+    ctx.logger.info("   Discovery: /.well-known/objectstack");
+    ctx.logger.info("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  }
+  /**
+   * Destroy Phase
+   *
+   * Cleans up all child plugins in reverse order.
+   */
+  async destroy() {
+    for (const plugin of [...this.childPlugins].reverse()) {
+      if (plugin.destroy) {
+        try {
+          await plugin.destroy();
+        } catch {
+        }
+      }
+    }
+  }
+  /**
+   * Seed a default admin user for development.
+   */
+  async seedAdmin(ctx) {
+    try {
+      const dataEngine = ctx.getService("data");
+      if (!dataEngine) return;
+      const existing = await dataEngine.find("user", {
+        filter: { email: "admin@dev.local" },
+        limit: 1
+      }).catch(() => null);
+      if (existing?.length) {
+        ctx.logger.debug("Dev admin user already exists");
+        return;
+      }
+      await dataEngine.insert("user", {
+        data: {
+          name: "Admin",
+          email: "admin@dev.local",
+          username: "admin",
+          role: "admin"
+        }
+      }).catch(() => {
+      });
+      ctx.logger.info("\u{1F511} Dev admin user seeded: admin@dev.local");
+    } catch {
+      ctx.logger.debug("Could not seed admin user (data engine may not be ready)");
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DevPlugin
+});
+//# sourceMappingURL=index.js.map