@milaboratories/pl-model-common 1.34.1 → 1.36.0

package/src/services/service_declarations.ts

@@ -1,6 +1,11 @@
 /**
  * Service declarations — add new services here.
  *
+ * `modelMethods` / `uiMethods` lists are the single source of truth for
+ * method names exposed on each side. They drive SERVICE_METHOD_MAP (UI
+ * ServiceProxy forwarders) and MODEL_SERVICE_METHOD_MAP (workflow VM
+ * bridge), so node/main/wasm split no longer needs introspection stubs.
+ *
  * After adding a service, fix type errors in these files:
  *
  * Model side:
@@ -8,18 +13,70 @@
  * - lib/node/pl-middle-layer/src/middle_layer/middle_layer.ts — ModelServiceRegistry factory
  *
  * UI side:
- * - lib/model/common/src/services/service_injector_factory.ts — driver method wrappers (node services only)
+ * - lib/model/common/src/services/node_service_handlers.ts — driver method wrappers (node services only)
  * - sdk/ui-vue/src/internal/createAppV3.ts — UiServiceRegistry factory
  *
+ * Electron main side (only for `main` services):
+ * - platforma-desktop-app/packages/main/src/services/mainServices.ts — main-process dispatcher
+ *
  * Optional:
  * - sdk/model/src/services/block_service_flags.ts — only if default-required by all blocks
  */
 
+import type { DialogService } from "../dialog";
 import type { PFrameDriver, PFrameModelDriver } from "../drivers/pframe/driver";
 import type { PFrameSpecDriver } from "../drivers/pframe/spec_driver";
 import { service } from "./service_types";
 
 export const Services = {
-  PFrameSpec: service<PFrameSpecDriver, PFrameSpecDriver>()({ type: "wasm", name: "pframeSpec" }),
-  PFrame: service<PFrameModelDriver, PFrameDriver>()({ type: "node", name: "pframe" }),
+  PFrameSpec: service<PFrameSpecDriver, PFrameSpecDriver>()({
+    type: "wasm",
+    name: "pframeSpec",
+    modelMethods: [
+      "createSpecFrame",
+      "listColumns",
+      "discoverColumns",
+      "deleteColumn",
+      "evaluateQuery",
+      "buildQuery",
+      "expandAxes",
+      "collapseAxes",
+      "findAxis",
+      "findTableColumn",
+    ] as const,
+    uiMethods: [
+      "createSpecFrame",
+      "listColumns",
+      "discoverColumns",
+      "deleteColumn",
+      "evaluateQuery",
+      "buildQuery",
+      "expandAxes",
+      "collapseAxes",
+      "findAxis",
+      "findTableColumn",
+    ] as const,
+  }),
+  PFrame: service<PFrameModelDriver, PFrameDriver>()({
+    type: "node",
+    name: "pframe",
+    modelMethods: ["createPFrame", "createPTable", "createPTableV2"] as const,
+    uiMethods: [
+      "findColumns",
+      "getColumnSpec",
+      "listColumns",
+      "calculateTableData",
+      "getUniqueValues",
+      "getShape",
+      "getSpec",
+      "getData",
+      "writePTableToFs",
+    ] as const,
+  }),
+  Dialog: service<Record<string, never>, DialogService>()({
+    type: "main",
+    name: "dialog",
+    modelMethods: [] as const,
+    uiMethods: ["showSaveDialog"] as const,
+  }),
 };

package/src/services/service_injectors.ts

@@ -1,17 +1,21 @@
 /**
- * UI service injectors — auto-derived types, method map, and service info builder.
+ * Service dispatch glue — auto-derived types, method maps, and service info builder.
  *
- * The factory (createUiServiceInjectors) lives in service_injector_factory.ts —
- * that's the only file to edit when adding a new node service.
+ * The worker-side handler factory (createNodeServiceHandlers) lives in
+ * node_service_handlers.ts — that's the only file to edit when adding a
+ * new node service. Method-name registries for UI and model sides are
+ * derived directly from the `uiMethods` / `modelMethods` declarations in
+ * service_declarations.ts — no factory introspection, no stubs.
  */
 
 import type { InferServiceKind, InferServiceUi, ServiceBrand, ServiceName } from "./service_types";
 import type { DriverKit } from "../driver_kit";
 import { Services } from "./service_declarations";
-import { getMethodNames, resolveRequiredServices } from "./service_capabilities";
-import { createUiServiceInjectors } from "./service_injector_factory";
+import { getServiceModelMethods, getServiceUiMethods } from "./service_types";
+import { resolveRequiredServices } from "./service_capabilities";
+import { createNodeServiceHandlers } from "./node_service_handlers";
 
-export { createUiServiceInjectors } from "./service_injector_factory";
+export { createNodeServiceHandlers } from "./node_service_handlers";
 
 type NodeServiceKeys = {
   [K in keyof typeof Services]: InferServiceKind<ServiceBrand<(typeof Services)[K]>> extends "node"
@@ -19,54 +23,66 @@ type NodeServiceKeys = {
     : never;
 }[keyof typeof Services];
 
-/** Auto-derived map of node service keys to their UI-side driver interfaces. */
-export type UiServiceInjectorMap = {
+/**
+ * Auto-derived map of node service keys to their UI-facing interfaces.
+ * Fulfilled by real driver wrappers in the worker. Main services are
+ * dispatched by the Electron main-process router and never reach this
+ * map; wasm services are instantiated locally on each consumer.
+ */
+export type NodeServiceHandlerMap = {
   [K in NodeServiceKeys]: InferServiceUi<ServiceBrand<(typeof Services)[K]>>;
 };
 
 let cachedKit: DriverKit | undefined;
-let cachedInjectors: UiServiceInjectorMap | undefined;
+let cachedHandlers: NodeServiceHandlerMap | undefined;
 
-function getOrCreateInjectors(driverKit: DriverKit): UiServiceInjectorMap {
-  if (!cachedInjectors || cachedKit !== driverKit) {
+function getOrCreateHandlers(driverKit: DriverKit): NodeServiceHandlerMap {
+  if (!cachedHandlers || cachedKit !== driverKit) {
     cachedKit = driverKit;
-    cachedInjectors = createUiServiceInjectors(driverKit);
+    cachedHandlers = createNodeServiceHandlers(driverKit);
   }
-  return cachedInjectors;
+  return cachedHandlers;
 }
 
-/** Resolve the injector for a given service ID. Caches injectors per DriverKit reference. */
-export function resolveUiInjector(
+/**
+ * Resolve the worker-side handler object for a given service ID. Caches
+ * per DriverKit reference. Called from the worker's IPC dispatch path.
+ */
+export function resolveNodeServiceHandler(
   driverKit: DriverKit,
   serviceId: ServiceName,
-): UiServiceInjectorMap[keyof UiServiceInjectorMap] | null {
-  const injectors = getOrCreateInjectors(driverKit);
+): NodeServiceHandlerMap[keyof NodeServiceHandlerMap] | null {
+  const handlers = getOrCreateHandlers(driverKit);
   const key = Object.keys(Services).find(
     (k) => Services[k as keyof typeof Services] === serviceId,
   ) as NodeServiceKeys | undefined;
   if (!key) return null;
-  return injectors[key];
+  return handlers[key];
 }
 
-/**
- * Static map of ServiceName → method names, auto-derived from the injector shape.
- * Computed once at module load. The stub DriverKit is never called — it only
- * provides a target so the closures in createUiServiceInjectors have own-property
- * keys that getMethodNames can introspect.
- */
-export const SERVICE_METHOD_MAP: Readonly<Record<string, string[]>> = (() => {
-  const stubKit = new Proxy({} as DriverKit, {
-    get: () => new Proxy({}, { get: () => () => {} }),
-  });
-  const injectors = createUiServiceInjectors(stubKit);
+function buildMethodMap(
+  pick: (id: ServiceName) => readonly string[],
+): Readonly<Record<string, string[]>> {
   const result: Record<string, string[]> = {};
-  for (const key of Object.keys(Services) as (keyof typeof Services)[]) {
-    const serviceId = Services[key];
-    const injector = injectors[key as NodeServiceKeys];
-    result[serviceId] = injector ? getMethodNames(injector) : [];
+  for (const id of Object.values(Services)) {
+    result[id as string] = [...pick(id)];
   }
   return result;
-})();
+}
+
+/**
+ * UI-side method names per service. Drives ServiceProxy forwarder
+ * construction in the renderer.
+ */
+export const SERVICE_METHOD_MAP: Readonly<Record<string, string[]>> =
+  buildMethodMap(getServiceUiMethods);
+
+/**
+ * Model-side method names per service. Drives the workflow VM bridge
+ * (see pl-middle-layer js_render).
+ */
+export const MODEL_SERVICE_METHOD_MAP: Readonly<Record<string, string[]>> =
+  buildMethodMap(getServiceModelMethods);
 
 /** Build service info for a block from its feature flags. */
 export function buildServiceInfo(

package/src/services/service_types.ts

@@ -22,19 +22,36 @@ export type InferServiceKind<S extends ServiceTypesLike> =
 
 export type ServiceName<S extends ServiceTypesLike = ServiceTypesLike> = Branded<string, S>;
 
-export type ServiceType = "node" | "wasm";
+export type ServiceType = "node" | "wasm" | "main";
 
 const SERVICE_ID_PATTERN = /^[a-zA-Z][a-zA-Z0-9]*$/;
 
-export const { service, isNodeService } = (() => {
+export const {
+  service,
+  isNodeService,
+  isWasmService,
+  isMainService,
+  getServiceKind,
+  getServiceModelMethods,
+  getServiceUiMethods,
+} = (() => {
   const typeMap = new Map<string, ServiceType>();
+  const modelMethodsMap = new Map<string, readonly string[]>();
+  const uiMethodsMap = new Map<string, readonly string[]>();
   return {
     service<Model, Ui>() {
-      return <K extends ServiceType, N extends string>(options: {
+      return <
+        K extends ServiceType,
+        N extends string,
+        MM extends readonly (keyof Model & string)[],
+        UM extends readonly (keyof Ui & string)[],
+      >(options: {
         readonly type: K;
         readonly name: N;
+        readonly modelMethods: MM;
+        readonly uiMethods: UM;
       }): Branded<N, ServiceTypesLike<Model, Ui, K>> => {
-        const { name, type } = options;
+        const { name, type, modelMethods, uiMethods } = options;
         if (!SERVICE_ID_PATTERN.test(name)) {
           throw new ServiceInvalidIdError(
             `Invalid service ID "${name}": must match ${SERVICE_ID_PATTERN}`,
@@ -44,12 +61,29 @@ export const { service, isNodeService } = (() => {
           throw new ServiceAlreadyRegisteredError(`Service "${name}" already registered`);
         }
         typeMap.set(name, type);
+        modelMethodsMap.set(name, modelMethods);
+        uiMethodsMap.set(name, uiMethods);
         return name as Branded<N, ServiceTypesLike<Model, Ui, K>>;
       };
     },
     isNodeService(id: ServiceName): boolean {
       return typeMap.get(id) === "node";
     },
+    isWasmService(id: ServiceName): boolean {
+      return typeMap.get(id) === "wasm";
+    },
+    isMainService(id: ServiceName): boolean {
+      return typeMap.get(id) === "main";
+    },
+    getServiceKind(id: ServiceName): ServiceType | undefined {
+      return typeMap.get(id);
+    },
+    getServiceModelMethods(id: ServiceName): readonly string[] {
+      return modelMethodsMap.get(id) ?? [];
+    },
+    getServiceUiMethods(id: ServiceName): readonly string[] {
+      return uiMethodsMap.get(id) ?? [];
+    },
   };
 })();
 

package/dist/services/service_injector_factory.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"service_injector_factory.cjs","names":[],"sources":["../../src/services/service_injector_factory.ts"],"sourcesContent":["/**\n * UI service injector factory.\n *\n * When adding a new node service, add its method wrappers here.\n * Everything else (SERVICE_METHOD_MAP, buildServiceInfo, UiServiceInjectorMap)\n * auto-derives from this factory + Services in service_declarations.ts.\n */\n\nimport type { DriverKit } from \"../driver_kit\";\nimport type { UiServiceInjectorMap } from \"./service_injectors\";\n\nexport function createUiServiceInjectors(driverKit: DriverKit): UiServiceInjectorMap {\n  const { pFrameDriver } = driverKit;\n  return {\n    PFrame: {\n      findColumns: (handle, request) => pFrameDriver.findColumns(handle, request),\n      getColumnSpec: (handle, columnId) => pFrameDriver.getColumnSpec(handle, columnId),\n      listColumns: (handle) => pFrameDriver.listColumns(handle),\n      calculateTableData: (handle, request, range) =>\n        pFrameDriver.calculateTableData(handle, request, range),\n      getUniqueValues: (handle, request) => pFrameDriver.getUniqueValues(handle, request),\n      getShape: (handle) => pFrameDriver.getShape(handle),\n      getSpec: (handle) => pFrameDriver.getSpec(handle),\n      getData: (handle, columnIndices, range) => pFrameDriver.getData(handle, columnIndices, range),\n    },\n  };\n}\n"],"mappings":";AAWA,SAAgB,yBAAyB,WAA4C;CACnF,MAAM,EAAE,iBAAiB;AACzB,QAAO,EACL,QAAQ;EACN,cAAc,QAAQ,YAAY,aAAa,YAAY,QAAQ,QAAQ;EAC3E,gBAAgB,QAAQ,aAAa,aAAa,cAAc,QAAQ,SAAS;EACjF,cAAc,WAAW,aAAa,YAAY,OAAO;EACzD,qBAAqB,QAAQ,SAAS,UACpC,aAAa,mBAAmB,QAAQ,SAAS,MAAM;EACzD,kBAAkB,QAAQ,YAAY,aAAa,gBAAgB,QAAQ,QAAQ;EACnF,WAAW,WAAW,aAAa,SAAS,OAAO;EACnD,UAAU,WAAW,aAAa,QAAQ,OAAO;EACjD,UAAU,QAAQ,eAAe,UAAU,aAAa,QAAQ,QAAQ,eAAe,MAAM;EAC9F,EACF"}

package/dist/services/service_injector_factory.d.ts

@@ -1,8 +0,0 @@
-import { DriverKit } from "../driver_kit.js";
-import { UiServiceInjectorMap } from "./service_injectors.js";
-
-//#region src/services/service_injector_factory.d.ts
-declare function createUiServiceInjectors(driverKit: DriverKit): UiServiceInjectorMap;
-//#endregion
-export { createUiServiceInjectors };
-//# sourceMappingURL=service_injector_factory.d.ts.map

package/dist/services/service_injector_factory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"service_injector_factory.d.ts","names":[],"sources":["../../src/services/service_injector_factory.ts"],"mappings":";;;;iBAWgB,wBAAA,CAAyB,SAAA,EAAW,SAAA,GAAY,oBAAA"}

package/dist/services/service_injector_factory.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"service_injector_factory.js","names":[],"sources":["../../src/services/service_injector_factory.ts"],"sourcesContent":["/**\n * UI service injector factory.\n *\n * When adding a new node service, add its method wrappers here.\n * Everything else (SERVICE_METHOD_MAP, buildServiceInfo, UiServiceInjectorMap)\n * auto-derives from this factory + Services in service_declarations.ts.\n */\n\nimport type { DriverKit } from \"../driver_kit\";\nimport type { UiServiceInjectorMap } from \"./service_injectors\";\n\nexport function createUiServiceInjectors(driverKit: DriverKit): UiServiceInjectorMap {\n  const { pFrameDriver } = driverKit;\n  return {\n    PFrame: {\n      findColumns: (handle, request) => pFrameDriver.findColumns(handle, request),\n      getColumnSpec: (handle, columnId) => pFrameDriver.getColumnSpec(handle, columnId),\n      listColumns: (handle) => pFrameDriver.listColumns(handle),\n      calculateTableData: (handle, request, range) =>\n        pFrameDriver.calculateTableData(handle, request, range),\n      getUniqueValues: (handle, request) => pFrameDriver.getUniqueValues(handle, request),\n      getShape: (handle) => pFrameDriver.getShape(handle),\n      getSpec: (handle) => pFrameDriver.getSpec(handle),\n      getData: (handle, columnIndices, range) => pFrameDriver.getData(handle, columnIndices, range),\n    },\n  };\n}\n"],"mappings":";AAWA,SAAgB,yBAAyB,WAA4C;CACnF,MAAM,EAAE,iBAAiB;AACzB,QAAO,EACL,QAAQ;EACN,cAAc,QAAQ,YAAY,aAAa,YAAY,QAAQ,QAAQ;EAC3E,gBAAgB,QAAQ,aAAa,aAAa,cAAc,QAAQ,SAAS;EACjF,cAAc,WAAW,aAAa,YAAY,OAAO;EACzD,qBAAqB,QAAQ,SAAS,UACpC,aAAa,mBAAmB,QAAQ,SAAS,MAAM;EACzD,kBAAkB,QAAQ,YAAY,aAAa,gBAAgB,QAAQ,QAAQ;EACnF,WAAW,WAAW,aAAa,SAAS,OAAO;EACnD,UAAU,WAAW,aAAa,QAAQ,OAAO;EACjD,UAAU,QAAQ,eAAe,UAAU,aAAa,QAAQ,QAAQ,eAAe,MAAM;EAC9F,EACF"}