@milaboratories/pl-middle-layer 1.42.2 → 1.42.4

package/dist/cfg_render/executor.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.cjs","sources":["../../src/cfg_render/executor.ts"],"sourcesContent":["import type {\n  ArgumentKey,\n  ArgumentValues,\n  ExecutionEnvironment,\n  Operation,\n  Subroutine,\n} from './operation';\nimport Denque from 'denque';\nimport { assertNever, notEmpty } from '@milaboratories/ts-helpers';\nimport type { ComputableCtx, ComputableRenderingOps } from '@milaboratories/computable';\nimport { Computable } from '@milaboratories/computable';\nimport type { Cfg } from '@platforma-sdk/model';\nimport { renderCfg, resOp } from './renderer';\nimport canonicalize from 'canonicalize';\nimport type { BlockContextAny } from '../middle_layer/block_ctx';\nimport type { MiddleLayerDriverKit } from '../middle_layer/driver_kit';\nimport { NonKeyCtxFields, toCfgContext } from '../middle_layer/block_ctx_unsafe';\n\n/** Addresses pending subroutines inside the stack */\ntype SubroutineKey = symbol;\n\n/** Represents destination of the result of an operation. I.e. when sequence of\n * subroutine invocations, and computables terminates with result, this object\n * determines to which argument of which pending subroutine it should be delivered.\n * See special value for delivery of the final \"return\" result. */\ntype Destination = {\n  op: SubroutineKey;\n  arg: ArgumentKey;\n};\n\n/** Special address of operation, see below. */\nconst ReturnOpKey: unique symbol = Symbol();\n/** The same, but for the argument part of destination, see below. */\nconst ReturnArgKey = 'return';\n\n/** Special destination, telling the executor that corresponding result should\n * be exposed as a final result, and execution terminate at this point. */\nconst ReturnDestination = { op: ReturnOpKey, arg: ReturnArgKey } as Destination;\n\nfunction isReturnDestination(destination: Destination): boolean {\n  return destination.op == ReturnOpKey && destination.arg == ReturnArgKey;\n}\n\n/** Queued operation, used inside the executor */\ntype QueuedOperation = {\n  operation: Operation;\n  destination: Destination;\n};\n\n/** Queued computation, returned by the first round of config execution. Such\n * computables should be returned in the intermediate representation of the\n * enclosing computable, and after they are resolved and passed to the\n * postprocessing routine, should be injected into the execution stack to\n * finalize the computation. */\ntype ScheduledComputable = {\n  destination: Destination;\n  computable: Computable<unknown>;\n};\n\n/** This is what ScheduledComputable transforms from intermediate\n * representation to post-processing. */\ntype MaterializedComputable = {\n  destination: Destination;\n  computable: unknown;\n};\n\n/** Main entry inside the execution stack. */\ntype PendingSubroutine = {\n  subroutine: Subroutine;\n  destination: Destination;\n  argCounter: number;\n  args: ArgumentValues;\n};\n\n/** Execution stack. The closest concept that this object along with enclosed\n * {@link PendingSubroutine}s represent is a Continuation.\n * https://en.wikipedia.org/wiki/Continuation */\ntype ExecutionStack = {\n  result?: unknown;\n  pendingSubroutines: Map<SubroutineKey, PendingSubroutine>;\n};\n\n/** Returns initial stack value. */\nfunction zeroStack(): ExecutionStack {\n  return { pendingSubroutines: new Map<SubroutineKey, PendingSubroutine>() };\n}\n\n/** Implements main executor mechanism.\n * @param env to be passed to while executing operations\n * @param stack execution stack to continue execution from\n * @param operations operations to initiate the execution process\n * @param allowComputables if false, scheduling of async computables will result in error\n * */\nfunction execute(\n  env: ExecutionEnvironment,\n  stack: ExecutionStack,\n  operations: QueuedOperation[],\n  allowComputables: boolean,\n): ScheduledComputable[] {\n  const operationQueue = new Denque<QueuedOperation>(operations);\n\n  /** Returns false if final result is set as result of this operation,\n   * true if we should continue processing. */\n  const deliverResult = (destination: Destination, result: unknown): boolean => {\n    if (isReturnDestination(destination)) {\n      stack.result = result;\n      return false;\n    }\n\n    const pending = notEmpty(stack.pendingSubroutines.get(destination.op));\n    if (destination.arg in pending.args) throw new Error('argument already set');\n    pending.args[destination.arg] = result;\n    pending.argCounter--;\n    if (pending.argCounter === 0) {\n      stack.pendingSubroutines.delete(destination.op);\n      operationQueue.push({\n        destination: pending.destination,\n        operation: pending.subroutine(pending.args),\n      });\n    }\n\n    return true;\n  };\n\n  // computables, scheduled during computation, are aggregated in this array,\n  // and returned from the function in the end\n  const computables: ScheduledComputable[] = [];\n\n  // each loop = execution of a single queued operation\n  mainLoop: while (operationQueue.length > 0) {\n    const op = operationQueue.shift()!;\n    const action = op.operation(env);\n    switch (action.type) {\n      case 'ReturnResult':\n        if (!deliverResult(op.destination, action.result)) break mainLoop; // this terminates execution\n        break; // switch\n\n      case 'ScheduleSubroutine':\n        {\n          const newOpKey = Symbol();\n\n          const argRequests = Object.entries(action.args);\n          const initialArgCounter = argRequests.length;\n\n          if (initialArgCounter === 0)\n          // if no pending arguments\n            operationQueue.push({\n              destination: op.destination,\n              operation: action.subroutine({}),\n            });\n          else {\n            for (const [arg, operation] of argRequests)\n              operationQueue.push({\n                destination: { op: newOpKey, arg },\n                operation,\n              });\n\n            stack.pendingSubroutines.set(newOpKey, {\n              argCounter: initialArgCounter,\n              args: {},\n              subroutine: action.subroutine,\n              destination: op.destination,\n            });\n          }\n        }\n        break;\n\n      case 'ScheduleComputable':\n        if (!allowComputables)\n          throw new Error('asynchronous operations are forbidden in this context');\n        computables.push({\n          destination: op.destination,\n          computable: action.computable,\n        });\n        break;\n\n      default:\n        assertNever(action);\n    }\n  }\n\n  return computables;\n}\n\n//\n// Computable\n//\n\n/** Main method to render configurations */\nexport function computableFromCfg(\n  drivers: MiddleLayerDriverKit,\n  bCtx: BlockContextAny,\n  cfg: Cfg,\n  ops: Partial<ComputableRenderingOps> = {},\n): Computable<unknown> {\n  return computableFromCfgUnsafe(drivers, toCfgContext(bCtx), cfg, ops);\n}\n\nexport function computableFromCfgUnsafe(\n  drivers: MiddleLayerDriverKit,\n  ctx: Record<string, unknown>,\n  cfg: Cfg,\n  ops: Partial<ComputableRenderingOps> = {},\n): Computable<unknown> {\n  const key\n    = `${ctx.blockId}#`\n    + canonicalize({\n      ctx: Object.fromEntries(\n        Object.entries(ctx).filter(([k]) => NonKeyCtxFields.indexOf(k) === -1),\n      ),\n      cfg: cfg,\n    })!;\n  return Computable.makeRaw(\n    (c) => {\n      const env: ExecutionEnvironment = { drivers, cCtx: c };\n      const stack = zeroStack();\n      const computables = execute(\n        env,\n        stack,\n        [\n          {\n            destination: ReturnDestination,\n            operation: renderCfg(ctx, cfg),\n          },\n        ],\n        true,\n      );\n      return {\n        ir: computables,\n        postprocessValue(value: MaterializedComputable[]): unknown {\n          const resolvedOps: QueuedOperation[] = [];\n          for (const mc of value)\n            resolvedOps.push({ destination: mc.destination, operation: resOp(mc.computable) });\n          const postEnv: ExecutionEnvironment = {\n            drivers,\n            get cCtx(): ComputableCtx {\n              throw new Error('asynchronous operations are forbidden in this context');\n            },\n          };\n\n          // Post process can be called several times, that's why it must be a side-effect-free function.\n          // But `execute` modifies a stack, so we have to defensively copy it here.\n          const copyOfPendingSubrotines = new Map<SubroutineKey, PendingSubroutine>();\n          for (const [key, value] of stack.pendingSubroutines)\n            copyOfPendingSubrotines.set(key, { ...value, args: { ...value.args } });\n          const copiedStack: ExecutionStack = {\n            result: stack.result,\n            pendingSubroutines: copyOfPendingSubrotines,\n          };\n          execute(postEnv, copiedStack, resolvedOps, false);\n          if (!('result' in copiedStack))\n            throw new Error('illegal cfg rendering stack state, no result');\n          return copiedStack.result;\n        },\n      };\n    },\n    { ...ops, key },\n  );\n}\n"],"names":["notEmpty","assertNever","toCfgContext","NonKeyCtxFields","Computable","renderCfg","resOp"],"mappings":"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"}

package/dist/cfg_render/executor.d.ts

@@ -5,4 +5,3 @@ import { MiddleLayerDriverKit } from '../middle_layer/driver_kit';
 /** Main method to render configurations */
 export declare function computableFromCfg(drivers: MiddleLayerDriverKit, bCtx: BlockContextAny, cfg: Cfg, ops?: Partial<ComputableRenderingOps>): Computable<unknown>;
 export declare function computableFromCfgUnsafe(drivers: MiddleLayerDriverKit, ctx: Record<string, unknown>, cfg: Cfg, ops?: Partial<ComputableRenderingOps>): Computable<unknown>;
-//# sourceMappingURL=executor.d.ts.map

package/dist/cfg_render/executor.js

@@ -0,0 +1,156 @@
+import Denque from 'denque';
+import { assertNever, notEmpty } from '@milaboratories/ts-helpers';
+import { Computable } from '@milaboratories/computable';
+import { renderCfg, resOp } from './renderer.js';
+import canonicalize from 'canonicalize';
+import { toCfgContext, NonKeyCtxFields } from '../middle_layer/block_ctx_unsafe.js';
+
+/** Special address of operation, see below. */
+const ReturnOpKey = Symbol();
+/** The same, but for the argument part of destination, see below. */
+const ReturnArgKey = 'return';
+/** Special destination, telling the executor that corresponding result should
+ * be exposed as a final result, and execution terminate at this point. */
+const ReturnDestination = { op: ReturnOpKey, arg: ReturnArgKey };
+function isReturnDestination(destination) {
+    return destination.op == ReturnOpKey && destination.arg == ReturnArgKey;
+}
+/** Returns initial stack value. */
+function zeroStack() {
+    return { pendingSubroutines: new Map() };
+}
+/** Implements main executor mechanism.
+ * @param env to be passed to while executing operations
+ * @param stack execution stack to continue execution from
+ * @param operations operations to initiate the execution process
+ * @param allowComputables if false, scheduling of async computables will result in error
+ * */
+function execute(env, stack, operations, allowComputables) {
+    const operationQueue = new Denque(operations);
+    /** Returns false if final result is set as result of this operation,
+     * true if we should continue processing. */
+    const deliverResult = (destination, result) => {
+        if (isReturnDestination(destination)) {
+            stack.result = result;
+            return false;
+        }
+        const pending = notEmpty(stack.pendingSubroutines.get(destination.op));
+        if (destination.arg in pending.args)
+            throw new Error('argument already set');
+        pending.args[destination.arg] = result;
+        pending.argCounter--;
+        if (pending.argCounter === 0) {
+            stack.pendingSubroutines.delete(destination.op);
+            operationQueue.push({
+                destination: pending.destination,
+                operation: pending.subroutine(pending.args),
+            });
+        }
+        return true;
+    };
+    // computables, scheduled during computation, are aggregated in this array,
+    // and returned from the function in the end
+    const computables = [];
+    // each loop = execution of a single queued operation
+    mainLoop: while (operationQueue.length > 0) {
+        const op = operationQueue.shift();
+        const action = op.operation(env);
+        switch (action.type) {
+            case 'ReturnResult':
+                if (!deliverResult(op.destination, action.result))
+                    break mainLoop; // this terminates execution
+                break; // switch
+            case 'ScheduleSubroutine':
+                {
+                    const newOpKey = Symbol();
+                    const argRequests = Object.entries(action.args);
+                    const initialArgCounter = argRequests.length;
+                    if (initialArgCounter === 0)
+                        // if no pending arguments
+                        operationQueue.push({
+                            destination: op.destination,
+                            operation: action.subroutine({}),
+                        });
+                    else {
+                        for (const [arg, operation] of argRequests)
+                            operationQueue.push({
+                                destination: { op: newOpKey, arg },
+                                operation,
+                            });
+                        stack.pendingSubroutines.set(newOpKey, {
+                            argCounter: initialArgCounter,
+                            args: {},
+                            subroutine: action.subroutine,
+                            destination: op.destination,
+                        });
+                    }
+                }
+                break;
+            case 'ScheduleComputable':
+                if (!allowComputables)
+                    throw new Error('asynchronous operations are forbidden in this context');
+                computables.push({
+                    destination: op.destination,
+                    computable: action.computable,
+                });
+                break;
+            default:
+                assertNever(action);
+        }
+    }
+    return computables;
+}
+//
+// Computable
+//
+/** Main method to render configurations */
+function computableFromCfg(drivers, bCtx, cfg, ops = {}) {
+    return computableFromCfgUnsafe(drivers, toCfgContext(bCtx), cfg, ops);
+}
+function computableFromCfgUnsafe(drivers, ctx, cfg, ops = {}) {
+    const key = `${ctx.blockId}#`
+        + canonicalize({
+            ctx: Object.fromEntries(Object.entries(ctx).filter(([k]) => NonKeyCtxFields.indexOf(k) === -1)),
+            cfg: cfg,
+        });
+    return Computable.makeRaw((c) => {
+        const env = { drivers, cCtx: c };
+        const stack = zeroStack();
+        const computables = execute(env, stack, [
+            {
+                destination: ReturnDestination,
+                operation: renderCfg(ctx, cfg),
+            },
+        ], true);
+        return {
+            ir: computables,
+            postprocessValue(value) {
+                const resolvedOps = [];
+                for (const mc of value)
+                    resolvedOps.push({ destination: mc.destination, operation: resOp(mc.computable) });
+                const postEnv = {
+                    drivers,
+                    get cCtx() {
+                        throw new Error('asynchronous operations are forbidden in this context');
+                    },
+                };
+                // Post process can be called several times, that's why it must be a side-effect-free function.
+                // But `execute` modifies a stack, so we have to defensively copy it here.
+                const copyOfPendingSubrotines = new Map();
+                for (const [key, value] of stack.pendingSubroutines)
+                    copyOfPendingSubrotines.set(key, { ...value, args: { ...value.args } });
+                const copiedStack = {
+                    result: stack.result,
+                    pendingSubroutines: copyOfPendingSubrotines,
+                };
+                execute(postEnv, copiedStack, resolvedOps, false);
+                if (!('result' in copiedStack))
+                    throw new Error('illegal cfg rendering stack state, no result');
+                return copiedStack.result;
+            },
+        };
+    }, { ...ops, key });
+}
+
+export { computableFromCfg, computableFromCfgUnsafe };
+//# sourceMappingURL=executor.js.map

package/dist/cfg_render/executor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.js","sources":["../../src/cfg_render/executor.ts"],"sourcesContent":["import type {\n  ArgumentKey,\n  ArgumentValues,\n  ExecutionEnvironment,\n  Operation,\n  Subroutine,\n} from './operation';\nimport Denque from 'denque';\nimport { assertNever, notEmpty } from '@milaboratories/ts-helpers';\nimport type { ComputableCtx, ComputableRenderingOps } from '@milaboratories/computable';\nimport { Computable } from '@milaboratories/computable';\nimport type { Cfg } from '@platforma-sdk/model';\nimport { renderCfg, resOp } from './renderer';\nimport canonicalize from 'canonicalize';\nimport type { BlockContextAny } from '../middle_layer/block_ctx';\nimport type { MiddleLayerDriverKit } from '../middle_layer/driver_kit';\nimport { NonKeyCtxFields, toCfgContext } from '../middle_layer/block_ctx_unsafe';\n\n/** Addresses pending subroutines inside the stack */\ntype SubroutineKey = symbol;\n\n/** Represents destination of the result of an operation. I.e. when sequence of\n * subroutine invocations, and computables terminates with result, this object\n * determines to which argument of which pending subroutine it should be delivered.\n * See special value for delivery of the final \"return\" result. */\ntype Destination = {\n  op: SubroutineKey;\n  arg: ArgumentKey;\n};\n\n/** Special address of operation, see below. */\nconst ReturnOpKey: unique symbol = Symbol();\n/** The same, but for the argument part of destination, see below. */\nconst ReturnArgKey = 'return';\n\n/** Special destination, telling the executor that corresponding result should\n * be exposed as a final result, and execution terminate at this point. */\nconst ReturnDestination = { op: ReturnOpKey, arg: ReturnArgKey } as Destination;\n\nfunction isReturnDestination(destination: Destination): boolean {\n  return destination.op == ReturnOpKey && destination.arg == ReturnArgKey;\n}\n\n/** Queued operation, used inside the executor */\ntype QueuedOperation = {\n  operation: Operation;\n  destination: Destination;\n};\n\n/** Queued computation, returned by the first round of config execution. Such\n * computables should be returned in the intermediate representation of the\n * enclosing computable, and after they are resolved and passed to the\n * postprocessing routine, should be injected into the execution stack to\n * finalize the computation. */\ntype ScheduledComputable = {\n  destination: Destination;\n  computable: Computable<unknown>;\n};\n\n/** This is what ScheduledComputable transforms from intermediate\n * representation to post-processing. */\ntype MaterializedComputable = {\n  destination: Destination;\n  computable: unknown;\n};\n\n/** Main entry inside the execution stack. */\ntype PendingSubroutine = {\n  subroutine: Subroutine;\n  destination: Destination;\n  argCounter: number;\n  args: ArgumentValues;\n};\n\n/** Execution stack. The closest concept that this object along with enclosed\n * {@link PendingSubroutine}s represent is a Continuation.\n * https://en.wikipedia.org/wiki/Continuation */\ntype ExecutionStack = {\n  result?: unknown;\n  pendingSubroutines: Map<SubroutineKey, PendingSubroutine>;\n};\n\n/** Returns initial stack value. */\nfunction zeroStack(): ExecutionStack {\n  return { pendingSubroutines: new Map<SubroutineKey, PendingSubroutine>() };\n}\n\n/** Implements main executor mechanism.\n * @param env to be passed to while executing operations\n * @param stack execution stack to continue execution from\n * @param operations operations to initiate the execution process\n * @param allowComputables if false, scheduling of async computables will result in error\n * */\nfunction execute(\n  env: ExecutionEnvironment,\n  stack: ExecutionStack,\n  operations: QueuedOperation[],\n  allowComputables: boolean,\n): ScheduledComputable[] {\n  const operationQueue = new Denque<QueuedOperation>(operations);\n\n  /** Returns false if final result is set as result of this operation,\n   * true if we should continue processing. */\n  const deliverResult = (destination: Destination, result: unknown): boolean => {\n    if (isReturnDestination(destination)) {\n      stack.result = result;\n      return false;\n    }\n\n    const pending = notEmpty(stack.pendingSubroutines.get(destination.op));\n    if (destination.arg in pending.args) throw new Error('argument already set');\n    pending.args[destination.arg] = result;\n    pending.argCounter--;\n    if (pending.argCounter === 0) {\n      stack.pendingSubroutines.delete(destination.op);\n      operationQueue.push({\n        destination: pending.destination,\n        operation: pending.subroutine(pending.args),\n      });\n    }\n\n    return true;\n  };\n\n  // computables, scheduled during computation, are aggregated in this array,\n  // and returned from the function in the end\n  const computables: ScheduledComputable[] = [];\n\n  // each loop = execution of a single queued operation\n  mainLoop: while (operationQueue.length > 0) {\n    const op = operationQueue.shift()!;\n    const action = op.operation(env);\n    switch (action.type) {\n      case 'ReturnResult':\n        if (!deliverResult(op.destination, action.result)) break mainLoop; // this terminates execution\n        break; // switch\n\n      case 'ScheduleSubroutine':\n        {\n          const newOpKey = Symbol();\n\n          const argRequests = Object.entries(action.args);\n          const initialArgCounter = argRequests.length;\n\n          if (initialArgCounter === 0)\n          // if no pending arguments\n            operationQueue.push({\n              destination: op.destination,\n              operation: action.subroutine({}),\n            });\n          else {\n            for (const [arg, operation] of argRequests)\n              operationQueue.push({\n                destination: { op: newOpKey, arg },\n                operation,\n              });\n\n            stack.pendingSubroutines.set(newOpKey, {\n              argCounter: initialArgCounter,\n              args: {},\n              subroutine: action.subroutine,\n              destination: op.destination,\n            });\n          }\n        }\n        break;\n\n      case 'ScheduleComputable':\n        if (!allowComputables)\n          throw new Error('asynchronous operations are forbidden in this context');\n        computables.push({\n          destination: op.destination,\n          computable: action.computable,\n        });\n        break;\n\n      default:\n        assertNever(action);\n    }\n  }\n\n  return computables;\n}\n\n//\n// Computable\n//\n\n/** Main method to render configurations */\nexport function computableFromCfg(\n  drivers: MiddleLayerDriverKit,\n  bCtx: BlockContextAny,\n  cfg: Cfg,\n  ops: Partial<ComputableRenderingOps> = {},\n): Computable<unknown> {\n  return computableFromCfgUnsafe(drivers, toCfgContext(bCtx), cfg, ops);\n}\n\nexport function computableFromCfgUnsafe(\n  drivers: MiddleLayerDriverKit,\n  ctx: Record<string, unknown>,\n  cfg: Cfg,\n  ops: Partial<ComputableRenderingOps> = {},\n): Computable<unknown> {\n  const key\n    = `${ctx.blockId}#`\n    + canonicalize({\n      ctx: Object.fromEntries(\n        Object.entries(ctx).filter(([k]) => NonKeyCtxFields.indexOf(k) === -1),\n      ),\n      cfg: cfg,\n    })!;\n  return Computable.makeRaw(\n    (c) => {\n      const env: ExecutionEnvironment = { drivers, cCtx: c };\n      const stack = zeroStack();\n      const computables = execute(\n        env,\n        stack,\n        [\n          {\n            destination: ReturnDestination,\n            operation: renderCfg(ctx, cfg),\n          },\n        ],\n        true,\n      );\n      return {\n        ir: computables,\n        postprocessValue(value: MaterializedComputable[]): unknown {\n          const resolvedOps: QueuedOperation[] = [];\n          for (const mc of value)\n            resolvedOps.push({ destination: mc.destination, operation: resOp(mc.computable) });\n          const postEnv: ExecutionEnvironment = {\n            drivers,\n            get cCtx(): ComputableCtx {\n              throw new Error('asynchronous operations are forbidden in this context');\n            },\n          };\n\n          // Post process can be called several times, that's why it must be a side-effect-free function.\n          // But `execute` modifies a stack, so we have to defensively copy it here.\n          const copyOfPendingSubrotines = new Map<SubroutineKey, PendingSubroutine>();\n          for (const [key, value] of stack.pendingSubroutines)\n            copyOfPendingSubrotines.set(key, { ...value, args: { ...value.args } });\n          const copiedStack: ExecutionStack = {\n            result: stack.result,\n            pendingSubroutines: copyOfPendingSubrotines,\n          };\n          execute(postEnv, copiedStack, resolvedOps, false);\n          if (!('result' in copiedStack))\n            throw new Error('illegal cfg rendering stack state, no result');\n          return copiedStack.result;\n        },\n      };\n    },\n    { ...ops, key },\n  );\n}\n"],"names":[],"mappings":"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"}

package/dist/cfg_render/executor.test.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=executor.test.d.ts.map

package/dist/cfg_render/operation.d.ts

@@ -26,4 +26,3 @@ export type ReturnResult = {
 };
 export type OperationAction = ScheduleSubroutine | ScheduleComputable | ReturnResult;
 export type Operation = (e: ExecutionEnvironment) => OperationAction;
-//# sourceMappingURL=operation.d.ts.map