@jarenjs/studio 0.73.0 → 0.83.2

package/src/resolve.js

@@ -0,0 +1,111 @@
+//@ts-check
+/** Project-local references. No fetching, evaluation or implicit merging. */
+import { setObjectMember, semanticKey } from '@jarenjs/core/object';
+import { StudioError } from './errors.js';
+
+const MEMBERS = {
+  app: ['view', 'actions', 'state', 'subs'],
+  fsm: ['states', 'transitions', 'initial'],
+  dag: ['nodes', 'edges', 'output'],
+  model: ['collections', 'entities'],
+};
+
+/** Resolve one file and its transitive sources. Imported members must be
+ * absent locally; a typo, cycle or collision is a refusal, never a fallback.
+ * @param {any} project @param {string} name
+ * @returns {{ doc: any, sourceFiles: string[] }} */
+export function resolveProjectFile(project, name) {
+  const visiting = new Set();
+  const sources = new Set();
+  const read = (name) => {
+    const file = project.files.find((f) => f.name === name);
+    if (!file) throw new StudioError('JS0003', `missing project file '${name}'`);
+    if (visiting.has(name)) throw new StudioError('JS0003', `cyclic file import at '${name}'`);
+    visiting.add(name);
+    sources.add(name);
+    let doc;
+    try { doc = JSON.parse(file.text); }
+    catch (cause) { throw new StudioError('JS0003', `${name}: not valid JSON`, '', { cause }); }
+    for (const [member, source] of Object.entries(file.imports ?? {})) {
+      if (!MEMBERS[file.kind]?.includes(member))
+        throw new StudioError('JS0003', `${name}: '${member}' is not an importable ${file.kind} member`);
+      if (!doc || typeof doc !== 'object' || Array.isArray(doc))
+        throw new StudioError('JS0003', `${name}: a fragment destination must be an object`);
+      if (Object.hasOwn(doc, member))
+        throw new StudioError('JS0003', `${name}: imported member '${member}' is also defined locally`);
+      setObjectMember(doc, member, read(source));
+    }
+    visiting.delete(name);
+    return doc;
+  };
+  return { doc: read(name), sourceFiles: [...sources] };
+}
+
+/** Resolve a query/transform/validation input or a worker store route.
+ * Explicit references never fall back when broken. Multiple models require
+ * a choice; adding an unrelated model cannot silently reroute a query.
+ * @param {any} project @param {any} file
+ * @returns {{ input: any, model: any, collection: string | null }} */
+export function projectFileContext(project, file) {
+  const named = (name, kinds) => {
+    const found = project.files.find((f) => f.name === name);
+    if (!found || !kinds.includes(found.kind))
+      throw new StudioError('JS0003', `${file.name}: '${name}' must name a ${kinds.join('/')} file`);
+    return found;
+  };
+  const input = file.input !== undefined ? named(file.input, ['data', 'state'])
+    : project.files.find((f) => f.kind === 'data') ?? project.files.find((f) => f.kind === 'state') ?? null;
+  const model = file.model !== undefined ? named(file.model, ['model']) : null;
+  if (file.collection !== undefined && model === null && file.kind !== 'model')
+    throw new StudioError('JS0003', `${file.name}: collection requires a model reference`);
+  return { input, model, collection: file.collection ?? null };
+}
+
+/** Rename references together with their target, preserving every other
+ * file member. A delete deliberately leaves references visibly broken.
+ * @param {any[]} files @param {string} before @param {string} after */
+export function renameProjectFile(files, before, after) {
+  if (!after || files.some((f) => f.name === after && f.name !== before))
+    throw new StudioError('JS0002', `a file is already named '${after}'`);
+  return files.map((file) => ({ ...file,
+    name: file.name === before ? after : file.name,
+    ...(file.input === before ? { input: after } : {}),
+    ...(file.model === before ? { model: after } : {}),
+    ...(file.imports ? { imports: Object.fromEntries(Object.entries(file.imports)
+      .map(([key, name]) => [key, name === before ? after : name])) } : {}),
+  }));
+}
+
+/** Write an assembled artifact back into its source files. Imported
+ * members stay in their own files; conflicting writes to a shared source
+ * are refused atomically. Unchanged files keep their identity and text.
+ * @param {any} project @param {string} name @param {any} doc */
+export function writeProjectArtifact(project, name, doc) {
+  resolveProjectFile(project, name); // resolve/cycle/collision check before any write
+  const writes = new Map();
+  const write = (name, value) => {
+    const key = semanticKey(value);
+    if (writes.has(name)) {
+      if (writes.get(name).key !== key) throw new StudioError('JS0003', `conflicting values for shared source '${name}'`);
+      return;
+    }
+    const file = project.files.find((f) => f.name === name);
+    let local = value;
+    if (file.imports) {
+      local = { ...value };
+      for (const [member, source] of Object.entries(file.imports)) {
+        if (!Object.hasOwn(value, member)) throw new StudioError('JS0003', `the edit removed imported member '${member}'`);
+        write(source, value[member]);
+        delete local[member];
+      }
+    }
+    writes.set(name, { key, local });
+  };
+  write(name, doc);
+  return project.files.map((file) => {
+    if (!writes.has(file.name)) return file;
+    const value = writes.get(file.name).local;
+    if (semanticKey(JSON.parse(file.text)) === semanticKey(value)) return file;
+    return { ...file, text: JSON.stringify(value, null, 2) };
+  });
+}

package/src/skeletons.js

@@ -0,0 +1,33 @@
+// @ts-check
+/** Valid starting documents, shared by the menu, host and assistant. */
+const SKELETONS = {
+  app: JSON.stringify({ state: {}, view: [{ match: '$', body: ['p', {}, 'New app'] }], actions: {} }, null, 2),
+  jslt: JSON.stringify({ $jslt: '0.1', rules: [{ match: '$', body: '$' }] }, null, 2),
+  query: JSON.stringify({ value: '$' }, null, 2),
+  fsm: JSON.stringify({ $fsm: '0.1', states: ['idle', 'done'], initial: 'idle', transitions: [{ from: 'idle', event: 'finish', to: 'done' }] }, null, 2),
+  dag: JSON.stringify({ $dag: '0.1', nodes: { input: { kind: 'input' }, output: { kind: 'output' } }, edges: [{ from: 'input', to: 'output' }], output: 'output' }, null, 2),
+  model: JSON.stringify({ $model: '0.1', collections: { notes: { schema: { type: 'object', properties: { id: { type: 'string' }, title: { type: 'string' }, points: { type: 'integer' } }, required: ['id'] }, key: '/id', indexes: [{ name: 'by_points', path: '$.points' }] } } }, null, 2),
+  state: '{}',
+  data: '{}',
+  schema: JSON.stringify({ type: 'object' }, null, 2),
+  contract: JSON.stringify({
+    $contract: '0.1',
+    operations: {
+      'echo.say': {
+        kind: 'command',
+        input: { type: 'object', required: ['text'], properties: { text: { type: 'string' } } },
+        output: true,
+      },
+    },
+  }, null, 2),
+};
+
+/** Creation kinds derive from the valid starter table and are shared by
+ * the component menu, website host and assistant. */
+export const ADDABLE_KINDS = Object.freeze(Object.keys(SKELETONS));
+
+/** The starter text for a freshly added file of `kind`, or null if the
+ * kind is not addable. */
+export function fileSkeleton(kind) {
+  return Object.hasOwn(SKELETONS, kind) ? SKELETONS[kind] : null;
+}

package/src/validate.js

@@ -12,7 +12,7 @@
  *               so host-registered operators ($npv, $sqrt) validate and a
  *               real error comes back as its own coded `JQ`/`JT` code with
  *               a docPath — the closed grammar would reject the operators;
- *  - `fsm` / `dag` / `model` → their published grammar (structural);
+ *  - `fsm` / `dag` / `model` → their grammar plus compiler/planner checks;
  *  - `contract` → COMPILED by `compileContract`, so a refusal comes back
  *               as its stable `JC00xx` code with the docPath of the
  *               member at fault — richer than the grammar alone;
@@ -31,6 +31,8 @@ import {
   compileJsltStylesheet, createJsltRegistry, mathPack, financePack, statsPack,
 } from '@jarenjs/json/jslt';
 import { compileContract } from '@jarenjs/contract';
+import { compileFsm, compileDag } from '@jarenjs/flow';
+import { normalizeModel, normalizeEntities, planCollection, planEntity, explainMapping, sqliteDialect } from '@jarenjs/db';
 
 import appSchema from '@jarenjs/app/schemas/jaren-app.schema.json' with { type: 'json' };
 import querySchema from '@jarenjs/json/schemas/jaren-query.schema.json' with { type: 'json' };
@@ -176,12 +178,29 @@ function validateFileUncached(file, options = {}) {
       return compileResult(kind, () => compileJsltStylesheet(doc, { compileTypeTest, ...registryOptions }));
     case 'query':
       return compileResult(kind, () => compileJsonQuery(doc, { compileTypeTest, ...registryOptions }));
-    case 'fsm':
-      return schemaResult(kind, validateFsm(doc));
-    case 'dag':
-      return schemaResult(kind, validateDag(doc));
-    case 'model':
-      return schemaResult(kind, validateModel(doc));
+    case 'fsm': {
+      const structural = schemaResult(kind, validateFsm(doc));
+      return structural.valid ? compileResult(kind, () => compileFsm(doc)) : structural;
+    }
+    case 'dag': {
+      const structural = schemaResult(kind, validateDag(doc));
+      if (!structural.valid) return structural;
+      // Validate named task nodes without acquiring or running host tasks.
+      const tasks = Object.fromEntries(Object.values(doc.nodes ?? {})
+        .filter((node) => node.kind === 'task').map((node) => [node.run, () => null]));
+      return compileResult(kind, () => compileDag(doc, { tasks }));
+    }
+    case 'model': {
+      const structural = schemaResult(kind, validateModel(doc));
+      if (!structural.valid) return structural;
+      return compileResult(kind, () => {
+        for (const [name, collection] of normalizeModel(doc)) planCollection(name, collection, sqliteDialect);
+        if (normalizeEntities(doc).size > 0) {
+          const mapping = explainMapping(doc);
+          for (const name of Object.keys(mapping.entities)) planEntity(name, mapping.entities[name], mapping, sqliteDialect);
+        }
+      });
+    }
     case 'contract':
       return compileResult(kind, () => compileContract(doc));
     case 'schema':

package/styles/studio.css

@@ -231,3 +231,17 @@
      plain vertical list again — the whole screen is the file list */
   .js-file-name { white-space: normal; overflow-wrap: anywhere; }
 }
+
+/* Per-file routing and the hosted flow/store stages. */
+.js-routing { display: flex; flex-wrap: wrap; gap: 8px; padding: 8px; font-size: .8rem; }
+.js-routing label { display: flex; align-items: center; gap: 4px; min-width: 0; }
+.js-routing input, .js-routing select { max-width: 180px; min-width: 0; }
+.project-flow, .project-data { min-width: 0; padding: 12px; }
+.project-flow .flow-grid { grid-template-columns: minmax(0, 1fr); }
+.project-data pre { white-space: pre-wrap; overflow-wrap: anywhere; }
+.project-data textarea { display: block; width: 100%; box-sizing: border-box; }
+.project-data label { display: block; margin-top: 12px; }
+.project-data button { margin: 8px 0; }
+.project-data button, .project-data input { min-height: 44px; }
+.project-data summary { cursor: pointer; padding: 12px 0; min-height: 44px; box-sizing: border-box; }
+.project-data input { box-sizing: border-box; }