@gotillit/tllt 0.3.0 → 0.3.5

package/deploy.js

@@ -2,7 +2,9 @@ import fs from 'fs';
 import {confirm} from '@inquirer/prompts';
 
 import {resolveProfile} from './lib/config.js';
-import {apiClient} from './lib/client.js';
+import {apiClient, fetchAsset} from './lib/client.js';
+import {getApi} from './lib/apis.js';
+import {distillSchema} from './lib/schema.js';
 import {computeChangeset} from './diff.js';
 import {info, result, isJsonMode} from './lib/output.js';
 import {
@@ -77,7 +79,7 @@ const doDeploy = async (opts = {}) => {
     }
   }
 
-  const applied = await applyChanges({targetProfile, to, changes});
+  const applied = await applyChanges({targetProfile, to, changes, profile: targetProfile});
   const counts = applied.reduce(
     (acc, a) => {
       acc[a.ok ? a.op : 'failed']++;
@@ -91,7 +93,7 @@ const doDeploy = async (opts = {}) => {
   return result('Deploy complete.', {ok: counts.failed === 0, to, counts, applied});
 };
 
-async function applyChanges({targetProfile, to, changes}) {
+async function applyChanges({targetProfile, to, changes, profile}) {
   const clients = new Map(); // api -> got client
   const getClient = async (api) => {
     if (!clients.has(api)) clients.set(api, await apiClient(targetProfile, api));
@@ -100,13 +102,21 @@ async function applyChanges({targetProfile, to, changes}) {
 
   const tplCache = {map: null};   // dataTemplate name -> {id, locationCode}
   const liveMaps = new Map();     // `${prefix}|${entity}` -> Map(naturalKey -> id)
+  const doSchemaCache = new Map(); // DO entity name -> distilled schema
 
   // Apply in dependency order: creates/updates ascending (parents before
-  // children), deletes descending (children before parents). DO changes are
-  // independent of scheduler ordering and keep their original order.
+  // children), deletes descending (children before parents). For DO we don't
+  // know cross-entity ordering, but within an entity we sort records with no
+  // self-parent (`parent == null`) first so children can resolve their parent
+  // refs to a live id on the same pass.
   const order = (c) => (c.api === 'scheduler' ? schedulerDeployOrder(c.entity) : 0);
-  const writes = changes.filter((c) => c.op !== 'delete').sort((a, b) => order(a) - order(b));
-  const deletes = changes.filter((c) => c.op === 'delete').sort((a, b) => order(b) - order(a));
+  const selfParentDepth = (c) => (c.record && c.record.parent == null ? 0 : 1);
+  const writes = changes
+    .filter((c) => c.op !== 'delete')
+    .sort((a, b) => order(a) - order(b) || selfParentDepth(a) - selfParentDepth(b));
+  const deletes = changes
+    .filter((c) => c.op === 'delete')
+    .sort((a, b) => order(b) - order(a) || selfParentDepth(b) - selfParentDepth(a));
 
   // Group consecutive changes by api+entity+dataTemplate so each live
   // collection is fetched once. Grouping preserves the dependency ordering.
@@ -121,7 +131,7 @@ async function applyChanges({targetProfile, to, changes}) {
     let ctx;
     try {
       const client = await getClient(api);
-      ctx = await resolveContext({client, api, meta, tplCache, liveMaps});
+      ctx = await resolveContext({client, api, meta, tplCache, liveMaps, profile, doSchemaCache});
     } catch (err) {
       for (const c of items) applied.push({...ref(c), ok: false, error: err.message});
       continue;
@@ -138,9 +148,24 @@ async function applyChanges({targetProfile, to, changes}) {
 
     for (const c of items) {
       try {
-        const body = desc ? resolveRefs(c.record, desc, lookups) : c.record;
+        // Deletes only need the live id and the URL — no body, so skip
+        // ref resolution entirely.
+        const body = c.op === 'delete' ? null : (desc ? resolveRefs(c.record, desc, lookups) : c.record);
         if (c.op === 'create') {
-          await client.post(collPath, {json: body});
+          const respBody = await client.post(collPath, {json: body}).json();
+          // Surface the new id in our in-memory caches so subsequent records
+          // in the same batch (e.g. children that reference this parent) can
+          // resolve against it without a live re-fetch.
+          const newId = respBody?.id;
+          if (newId != null) {
+            ownMap.set(c.key, newId);
+            for (const [lookupKey, lookupMap] of lookups) {
+              if (!lookupKey.startsWith(`${meta.entity}@`)) continue;
+              const kf = lookupKey.slice(meta.entity.length + 1);
+              const kv = c.record?.[kf];
+              if (kv != null) lookupMap.set(String(kv), newId);
+            }
+          }
         } else {
           const id = ownMap.get(c.key);
           if (id == null) throw new Error(`No live ${meta.entity} keyed "${c.key}" to ${c.op}.`);
@@ -178,9 +203,59 @@ function groupChanges(changes) {
  * entities, bare `{endpoint}` for global ones), and the live key→id lookup maps
  * needed to resolve id references in the body.
  */
-async function resolveContext({client, api, meta, tplCache, liveMaps}) {
+async function resolveContext({client, api, meta, tplCache, liveMaps, profile, doSchemaCache}) {
   if (api !== 'scheduler') {
-    return {collPath: `${meta.microservice}/${meta.endpoint}`, desc: null, lookups: new Map(), prefix: '', dataTemplateId: null};
+    const collPath = `${meta.microservice}/${meta.endpoint}`;
+    // Build a desc + lookups so DO bodies get their {name:..} refs resolved
+    // to {id:..} the same way scheduler does. Without this, the DO API
+    // receives un-resolved name refs and silently drops them on update
+    // (assets) or rejects on create (option items).
+    if (!profile) return {collPath, desc: null, lookups: new Map(), prefix: '', dataTemplateId: null};
+    let schema;
+    try {
+      schema = await getDoSchema(profile, meta.entity, doSchemaCache);
+    } catch (err) {
+      // If the schema can't be fetched, fall back to the original pass-through
+      // behaviour so we don't regress entities the user could deploy before.
+      return {collPath, desc: null, lookups: new Map(), prefix: '', dataTemplateId: null};
+    }
+    // For DO we treat every ref as nullable client-side and let the API
+    // enforce its own required rules. Two reasons: (a) imported records often
+    // have legitimately-null refs (e.g. Asset.calendar) that the schema marks
+    // required, and (b) on update the API merges, so omitting a field is a
+    // valid no-op.
+    const refs = (schema.relationships || []).map((r) => ({
+      field: r.name,
+      kind: 'id',
+      nullable: true,
+      keyField: r.keyField || 'name',
+      lookupEntity: r.references,
+      keyOf: (val) => (val == null ? null : val[r.keyField || 'name']),
+    }));
+    // DO refs may key by `value` (etc.), so we tag the lookup key with the
+    // keyField. resolveRefs reads lookups by ref.lookupEntity, so we rewrite
+    // each ref's lookupEntity to include the keyField suffix and store the
+    // matching map under the same composite key.
+    const desc = {entityName: meta.entity, refs: refs.map((r) => ({...r, lookupEntity: `${r.lookupEntity}@${r.keyField}`}))};
+    const lookups = new Map();
+    for (const r of refs) {
+      let refSchema;
+      try {
+        refSchema = await getDoSchema(profile, r.lookupEntity, doSchemaCache);
+      } catch (err) {
+        continue;
+      }
+      const refCollPath = refSchema.microservice
+        ? `${refSchema.microservice}/${refSchema.endpoint}`
+        : refSchema.endpoint;
+      const map = await liveKeyIdMap({
+        client, api, collPath: refCollPath, desc: null, liveMaps,
+        prefix: '', entity: r.lookupEntity, dataTemplateId: null,
+        keyField: r.keyField,
+      });
+      lookups.set(`${r.lookupEntity}@${r.keyField}`, map);
+    }
+    return {collPath, desc, lookups, prefix: '', dataTemplateId: null};
   }
   const desc = getSchedulerEntity(meta.entity);
   if (!desc) throw new Error(`Unknown scheduler entity "${meta.entity}"; re-import.`);
@@ -252,8 +327,11 @@ async function resolveTemplate(client, name, tplCache) {
  * keys are computed with the entity descriptor (matching the snapshot keys) and
  * request the `expand` relations those keys depend on; DO falls back to name/code.
  */
-async function liveKeyIdMap({client, api, collPath, desc, liveMaps, prefix, entity, dataTemplateId}) {
-  const cacheKey = `${prefix}|${entity}`;
+async function liveKeyIdMap({client, api, collPath, desc, liveMaps, prefix, entity, dataTemplateId, keyField}) {
+  // DO refs may resolve by a non-name field (e.g. OptionItem.parent uses
+  // `value`). Include keyField in the cache key so name and value maps for the
+  // same entity don't collide.
+  const cacheKey = `${prefix}|${entity}|${keyField ?? 'natural'}`;
   if (liveMaps.has(cacheKey)) return liveMaps.get(cacheKey);
 
   const expand = api === 'scheduler' && desc ? expandParam(desc) : undefined;
@@ -267,13 +345,26 @@ async function liveKeyIdMap({client, api, collPath, desc, liveMaps, prefix, enti
   const map = new Map();
   for (const r of records) {
     if (r?.id == null) continue;
-    const key = api === 'scheduler' && desc ? matchKey(r, desc) : r?.name ?? r?.code;
+    let key;
+    if (api === 'scheduler' && desc) key = matchKey(r, desc);
+    else if (keyField) key = r?.[keyField];
+    else key = r?.name ?? r?.code;
     if (key != null) map.set(String(key), r.id);
   }
   liveMaps.set(cacheKey, map);
   return map;
 }
 
+async function getDoSchema(profile, entityName, cache) {
+  if (cache.has(entityName)) return cache.get(entityName);
+  const apiId = 'do';
+  const api = getApi(apiId);
+  const raw = await fetchAsset(profile, apiId, `${api.schemaPath}/${entityName}.json`);
+  const schema = distillSchema(raw, apiId);
+  cache.set(entityName, schema);
+  return schema;
+}
+
 function ref(c) {
   return {op: c.op, api: c.api, entity: c.entity, key: c.key};
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotillit/tllt",
-  "version": "0.3.0",
+  "version": "0.3.5",
   "description": "TilliT CLI — manage TilliT configuration across the Digital Operations and Scheduler APIs. Built to be agent- and install-friendly: bootstrap a connection once, then import / diff / deploy.",
   "main": "tllt.js",
   "type": "module",

package/tllt.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import {readFileSync} from 'node:fs';
 import {Command} from 'commander';
 
 import doConfigure from './configure.js';
@@ -9,6 +10,8 @@ import doSchema from './schema.js';
 import {listProfiles} from './lib/config.js';
 import {setJsonMode, run, result, info} from './lib/output.js';
 
+const {version} = JSON.parse(readFileSync(new URL('./package.json', import.meta.url)));
+
 const program = new Command();
 
 program
@@ -26,7 +29,7 @@ program
       'Agents: read AGENTS.md and docs/ to learn the tool; pass --json for machine output.',
     ].join('\n')
   )
-  .version('0.3.0')
+  .version(version)
   .option('-p, --profile <name>', 'connection profile to use (default: the configured default)')
   .option('--json', 'emit machine-readable JSON on stdout (agent-friendly)');