@milaboratories/pl-middle-layer 1.23.19 → 1.25.0

package/src/mutator/project.ts

@@ -49,7 +49,12 @@ import {
 } from '../model/project_model_util';
 import { BlockPackSpecPrepared } from '../model';
 import { notEmpty } from '@milaboratories/ts-helpers';
-import { AuthorMarker, ProjectMeta } from '@milaboratories/pl-model-middle-layer';
+import {
+  AuthorMarker,
+  BlockSettings,
+  InitialBlockSettings,
+  ProjectMeta
+} from '@milaboratories/pl-model-middle-layer';
 import Denque from 'denque';
 import { exportContext, getPreparedExportTemplateEnvelope } from './context_export';
 import { loadTemplate } from './template/template_loading';
@@ -64,6 +69,7 @@ interface BlockFieldState {
 }
 
 type BlockFieldStates = Partial<Record<ProjectField['fieldName'], BlockFieldState>>;
+type BlockFieldStateValue = Omit<BlockFieldState, 'modCount'>;
 
 interface BlockInfoState {
   readonly id: string;
@@ -234,7 +240,8 @@ export class ProjectMutator {
     private readonly ctxExportTplHolder: AnyResourceRef
   ) {}
 
-  private fixProblems() {
+  private fixProblemsAndMigrate() {
+    // Fixing problems introduced by old code
     this.blockInfos.forEach((blockInfo) => {
       if (
         blockInfo.fields.prodArgs === undefined ||
@@ -243,6 +250,16 @@ export class ProjectMutator {
       )
         this.deleteBlockFields(blockInfo.id, 'prodArgs', 'prodOutput', 'prodCtx');
     });
+
+    // Migration for addition of block settings field
+    let initialBlockSettings: Omit<BlockFieldState, 'modCount'> | undefined;
+    this.blockInfos.forEach((blockInfo) => {
+      if (blockInfo.fields.blockSettings === undefined) {
+        if (initialBlockSettings === undefined)
+          initialBlockSettings = this.createJsonFieldValue(InitialBlockSettings);
+        this.setBlockFieldObj(blockInfo.id, 'blockSettings', initialBlockSettings);
+      }
+    });
   }
 
   get wasModified(): boolean {
@@ -297,7 +314,19 @@ export class ProjectMutator {
   //
 
   private getBlockInfo(blockId: string): BlockInfo {
-    return notEmpty(this.blockInfos.get(blockId));
+    const info = this.blockInfos.get(blockId);
+    if (info === undefined) throw new Error(`No such block: ${blockId}`);
+    return info;
+  }
+
+  private createJsonFieldValueByContent(content: string): BlockFieldStateValue {
+    const value = Buffer.from(content);
+    const ref = this.tx.createValue(Pl.JsonObject, value);
+    return { ref, value, status: 'Ready' };
+  }
+
+  private createJsonFieldValue(obj: unknown): BlockFieldStateValue {
+    return this.createJsonFieldValueByContent(JSON.stringify(obj));
   }
 
   private getBlock(blockId: string): Block {
@@ -308,7 +337,7 @@ export class ProjectMutator {
   private setBlockFieldObj(
     blockId: string,
     fieldName: keyof BlockFieldStates,
-    state: Omit<BlockFieldState, 'modCount'>
+    state: BlockFieldStateValue
   ) {
     const fid = field(this.rid, projectFieldName(blockId, fieldName));
 
@@ -447,6 +476,11 @@ export class ProjectMutator {
     this.updateLastModified();
   }
 
+  public setBlockSettings(blockId: string, newValue: BlockSettings): void {
+    this.setBlockFieldObj(blockId, 'blockSettings', this.createJsonFieldValue(newValue));
+    this.updateLastModified();
+  }
+
   /** Update block label */
   // public setBlockLabel(blockId: string, label: string): void {
   //   const newStructure = this.structure;
@@ -586,10 +620,15 @@ export class ProjectMutator {
       const bp = createBlockPack(this.tx, spec.blockPack);
       this.setBlockField(blockId, 'blockPack', Pl.wrapInHolder(this.tx, bp), 'NotReady');
 
+      // settings
+      this.setBlockFieldObj(
+        blockId,
+        'blockSettings',
+        this.createJsonFieldValue(InitialBlockSettings)
+      );
+
       // args
-      const binArgs = Buffer.from(spec.args);
-      const argsRes = this.tx.createValue(Pl.JsonObject, binArgs);
-      this.setBlockField(blockId, 'currentArgs', argsRes, 'Ready', binArgs);
+      this.setBlockFieldObj(blockId, 'currentArgs', this.createJsonFieldValueByContent(spec.args));
 
       // uiState
       if (spec.uiState /* this check is for compatibility with old configs */) {
@@ -1052,7 +1091,7 @@ export class ProjectMutator {
       ctxExportTplHolder
     );
 
-    prj.fixProblems();
+    prj.fixProblemsAndMigrate();
 
     return prj;
   }

package/src/mutator/template/direct_template_loader.ts

@@ -3,8 +3,18 @@ import { assertNever } from '@milaboratories/ts-helpers';
 import type { ExplicitTemplate } from '../../model/template_spec';
 import type { Hash } from 'node:crypto';
 import { createHash } from 'node:crypto';
-import type { TemplateData, TemplateLibData, TemplateSoftwareData } from '@milaboratories/pl-model-backend';
-import { PlTemplateLibV1, PlTemplateSoftwareV1, PlTemplateV1, PlTemplateOverrideV1, parseTemplate } from '@milaboratories/pl-model-backend';
+import type {
+  TemplateData,
+  TemplateLibData,
+  TemplateSoftwareData
+} from '@milaboratories/pl-model-backend';
+import {
+  PlTemplateLibV1,
+  PlTemplateSoftwareV1,
+  PlTemplateV1,
+  PlTemplateOverrideV1,
+  parseTemplate
+} from '@milaboratories/pl-model-backend';
 
 export function loadTemplateFromExplicitDirect(tx: PlTransaction, spec: ExplicitTemplate): AnyRef {
   const templateInfo: TemplateData = parseTemplate(spec.content);
@@ -20,10 +30,10 @@ export function loadTemplateFromExplicitDirect(tx: PlTransaction, spec: Explicit
 
 type Renderer<T> = {
   hash: Hasher<T>;
-  render: (resource: T, tx: PlTransaction, creator: Creator<T>) => AnyResourceRef;
+  render: (resource: T, tx: PlTransaction, creator: Creator) => AnyResourceRef;
 };
 type Hasher<T> = (resource: T, hash: Hash) => void;
-type Creator<T> = (resource: T, renderer: Renderer<T>) => AnyResourceRef;
+type Creator = <T>(resource: T, renderer: Renderer<T>) => AnyResourceRef;
 
 const LibRenderer: Renderer<TemplateLibData> = {
   hash(resource, hash) {
@@ -37,9 +47,9 @@ const LibRenderer: Renderer<TemplateLibData> = {
   render(resource, tx, _creator) {
     return tx.createValue(
       PlTemplateLibV1.type,
-      JSON.stringify(PlTemplateLibV1.fromV2Data(resource).data),
+      JSON.stringify(PlTemplateLibV1.fromV2Data(resource).data)
     );
-  },
+  }
 };
 
 const SoftwareInfoRenderer: Renderer<TemplateSoftwareData> = {
@@ -57,7 +67,22 @@ const SoftwareInfoRenderer: Renderer<TemplateSoftwareData> = {
     tx.setKValue(ref, PlTemplateSoftwareV1.metaNameKey, JSON.stringify(sw.name));
     tx.lock(ref);
     return ref;
+  }
+};
+
+const HashOverrideRenderer: Renderer<TemplateData> = {
+  hash(resource, hash) {
+    hash
+      .update(PlTemplateOverrideV1.type.name)
+      .update(PlTemplateOverrideV1.type.version)
+      .update(resource.hashOverride ?? '');
   },
+  render(resource, tx, _creator) {
+    return tx.createStruct(
+      PlTemplateOverrideV1.type,
+      JSON.stringify(PlTemplateOverrideV1.fromV2Data(resource))
+    );
+  }
 };
 
 const TemplateRenderer: Renderer<TemplateData> = {
@@ -70,8 +95,8 @@ const TemplateRenderer: Renderer<TemplateData> = {
       .update(resource.version)
       .update(resource.src);
 
-    const srt = <T>(entries: [string, T][]) : [string, T][] => {
-      entries.sort((a, b) => a[0] === b[0] ? 0 : a[0] < b[0] ? -1 : 1);
+    const srt = <T>(entries: [string, T][]): [string, T][] => {
+      entries.sort((a, b) => (a[0] === b[0] ? 0 : a[0] < b[0] ? -1 : 1));
       return entries;
     };
 
@@ -93,32 +118,52 @@ const TemplateRenderer: Renderer<TemplateData> = {
     }
   },
   render(resource, tx, _creator) {
-    return tx.createStruct(
+    const tplRef = tx.createStruct(
       PlTemplateV1.type,
-      JSON.stringify(PlTemplateV1.fromV2Data(resource).data),
+      JSON.stringify(PlTemplateV1.fromV2Data(resource).data)
     );
-  },
-};
+    // Render libraries
+    for (const [libId, lib] of Object.entries(resource.libs ?? {})) {
+      const fld = PlTemplateV1.libField(tplRef, libId);
+      tx.createField(fld, 'Input');
+      tx.setField(fld, _creator(lib, LibRenderer));
+    }
 
-const HashOverrideRenderer: Renderer<TemplateData> = {
-  hash(resource, hash) {
-    hash
-      .update(PlTemplateOverrideV1.type.name)
-      .update(PlTemplateOverrideV1.type.version)
-      .update(resource.hashOverride ?? '');
-  },
-  render(resource, tx, _creator) {
-    return tx.createStruct(
-      PlTemplateOverrideV1.type,
-      JSON.stringify(PlTemplateOverrideV1.fromV2Data(resource)),
-    );
-  },
-};
+    // Render software and assets
+    for (const [swId, sw] of Object.entries(resource.software ?? {})) {
+      const fld = PlTemplateV1.swField(tplRef, swId);
+      tx.createField(fld, 'Input');
+      tx.setField(fld, _creator(sw, SoftwareInfoRenderer));
+    }
+    for (const [swId, sw] of Object.entries(resource.assets ?? {})) {
+      const fld = PlTemplateV1.swField(tplRef, swId);
+      tx.createField(fld, 'Input');
+      tx.setField(fld, _creator(sw, SoftwareInfoRenderer));
+    }
+
+    // Render dependency templates
+    for (const [depTplId, depTpl] of Object.entries(resource.templates ?? {})) {
+      const fld = PlTemplateV1.tplField(tplRef, depTplId);
+      tx.createField(fld, 'Input');
+      tx.setField(fld, _creator(depTpl, TemplateRenderer));
+    }
+
+    tx.lock(tplRef);
+
+    if (!resource.hashOverride) return tplRef;
 
-function createTemplateV2Tree(tx: PlTransaction, tplInfo: TemplateData, resourceCache?: Map<string, AnyResourceRef>): AnyRef {
-  if (!resourceCache) {
-    resourceCache = new Map<string, AnyResourceRef>();
+    // Override template hash with proxy resource, when hash override is configured for template
+    const overrideRef = _creator(resource, HashOverrideRenderer);
+    const fld = PlTemplateOverrideV1.tplField(overrideRef);
+    tx.createField(fld, 'Service');
+    tx.setField(fld, tplRef);
+    tx.lock(tplRef);
+    return overrideRef;
   }
+};
+
+function createTemplateV2Tree(tx: PlTransaction, tplInfo: TemplateData): AnyRef {
+  const resourceCache = new Map<string, AnyResourceRef>();
 
   const createResource = <T>(resource: T, renderer: Renderer<T>): AnyResourceRef => {
     const hasher: Hash = createHash('sha256');
@@ -133,45 +178,5 @@ function createTemplateV2Tree(tx: PlTransaction, tplInfo: TemplateData, resource
     return resourceCache.get(rKey)!;
   };
 
-  const tplRef = createResource(tplInfo, TemplateRenderer);
-
-  // Render libraries
-  for (const [libId, lib] of Object.entries(tplInfo.libs ?? {})) {
-    const fld = PlTemplateV1.libField(tplRef, libId);
-    tx.createField(fld, 'Input');
-    tx.setField(fld, createResource(lib, LibRenderer));
-  }
-
-  // Render software and assets
-  for (const [swId, sw] of Object.entries(tplInfo.software ?? {})) {
-    const fld = PlTemplateV1.swField(tplRef, swId);
-    tx.createField(fld, 'Input');
-    tx.setField(fld, createResource(sw, SoftwareInfoRenderer));
-  }
-  for (const [swId, sw] of Object.entries(tplInfo.assets ?? {})) {
-    const fld = PlTemplateV1.swField(tplRef, swId);
-    tx.createField(fld, 'Input');
-    tx.setField(fld, createResource(sw, SoftwareInfoRenderer));
-  }
-
-  // Render dependency templates
-  for (const [depTplId, depTpl] of Object.entries(tplInfo.templates ?? {})) {
-    const fld = PlTemplateV1.tplField(tplRef, depTplId);
-    tx.createField(fld, 'Input');
-    tx.setField(fld, createTemplateV2Tree(tx, depTpl, resourceCache));
-  }
-
-  tx.lock(tplRef);
-
-  if (!tplInfo.hashOverride) {
-    return tplRef;
-  }
-
-  // Override template hash with proxy resource, when hash override is configured for template
-  const overrideRef = createResource(tplInfo, HashOverrideRenderer);
-  const fld = PlTemplateOverrideV1.tplField(overrideRef);
-  tx.createField(fld, 'Service');
-  tx.setField(fld, tplRef);
-  tx.lock(tplRef);
-  return overrideRef;
+  return createResource(tplInfo, TemplateRenderer);
 }