@reventlessdev/reventless-core 3.0.0-alpha.215 → 3.0.0-alpha.217

package/src/plugin/component/Plugin_Structure.res.mjs

@@ -140,6 +140,62 @@ function labelFieldsFromStateSchema(entityName, stateSchema) {
   };
 }
 
+function toEventDef(v) {
+  let mkDef = (variantName, properties) => {
+    let references = Stdlib_Array.filterMap(Object.entries(properties), param => {
+      let fieldName = param[0];
+      return Stdlib_Option.map(Reference$Reventless.getTarget(param[1]), target => ({
+        fieldName: fieldName,
+        entity: target.entity,
+        plugin: target.plugin
+      }));
+    });
+    return {
+      name: variantName,
+      schema: JSON.stringify(SuryToJsonSchema$ReventlessCore.deriveObjectSchema(v)),
+      references: references
+    };
+  };
+  switch (v.type) {
+    case "string" :
+      let variantName = v.const;
+      if (variantName !== undefined) {
+        return mkDef(variantName, {});
+      } else {
+        return;
+      }
+    case "object" :
+      let properties = v.properties;
+      return Stdlib_Option.flatMap(properties["TAG"], tagSchema => {
+        if (tagSchema.type !== "string") {
+          return;
+        }
+        let variantName = tagSchema.const;
+        if (variantName !== undefined) {
+          return mkDef(variantName, properties);
+        }
+      });
+    default:
+      return;
+  }
+}
+
+function extractEventDefs(eventSchema) {
+  if (eventSchema.type === "union") {
+    return Stdlib_Array.filterMap(eventSchema.anyOf, toEventDef);
+  } else {
+    return Stdlib_Option.mapOr(toEventDef(eventSchema), [], def => [def]);
+  }
+}
+
+function extractErrorDefs(errorSchema) {
+  return extractEventDefs(errorSchema).map(param => ({
+    name: param.name,
+    schema: param.schema,
+    references: param.references
+  }));
+}
+
 function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChangeSlicesOpt, automationSlicesOpt, outboundTranslationSlicesOpt, inboundTranslationSlicesOpt, extensionsOpt, extensionPointsOpt, componentChaptersOpt) {
   let aggregates = aggregatesOpt !== undefined ? aggregatesOpt : [];
   let readModels = readModelsOpt !== undefined ? readModelsOpt : [];
@@ -268,52 +324,6 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
       return Stdlib_Option.mapOr(toCommandDef(isAggregate, mutationFieldFor, commandSchema, commandSchema), [], def => [def]);
     }
   };
-  let toEventDef = v => {
-    let mkDef = (variantName, properties) => {
-      let references = Stdlib_Array.filterMap(Object.entries(properties), param => {
-        let fieldName = param[0];
-        return Stdlib_Option.map(Reference$Reventless.getTarget(param[1]), target => ({
-          fieldName: fieldName,
-          entity: target.entity,
-          plugin: target.plugin
-        }));
-      });
-      return {
-        name: variantName,
-        schema: JSON.stringify(SuryToJsonSchema$ReventlessCore.deriveObjectSchema(v)),
-        references: references
-      };
-    };
-    switch (v.type) {
-      case "string" :
-        let variantName = v.const;
-        if (variantName !== undefined) {
-          return mkDef(variantName, {});
-        } else {
-          return;
-        }
-      case "object" :
-        let properties = v.properties;
-        return Stdlib_Option.flatMap(properties["TAG"], tagSchema => {
-          if (tagSchema.type !== "string") {
-            return;
-          }
-          let variantName = tagSchema.const;
-          if (variantName !== undefined) {
-            return mkDef(variantName, properties);
-          }
-        });
-      default:
-        return;
-    }
-  };
-  let extractEventDefs = eventSchema => {
-    if (eventSchema.type === "union") {
-      return Stdlib_Array.filterMap(eventSchema.anyOf, toEventDef);
-    } else {
-      return Stdlib_Option.mapOr(toEventDef(eventSchema), [], def => [def]);
-    }
-  };
   let scsProduced = stateChangeSlices.map(SCS => [
     SCS.Spec.name,
     qualify(name, DcbTag$Reventless.extractVariantNames(SCS.Spec.eventSchema))
@@ -541,6 +551,7 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
       linkedViews: linkedSvsFor(produced),
       consistencyRead: consistencyReadFor(consumed),
       events: extractEventDefs(SCS.Spec.eventSchema),
+      errors: extractErrorDefs(SCS.Spec.errorSchema),
       chapter: componentChapters[SCS.Spec.name]
     };
   });
@@ -555,6 +566,7 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
       linkedViews: linkedSvsFor(produced).concat(linkedReadModelsFor(A.Spec.name)),
       consistencyRead: undefined,
       events: extractEventDefs(A.Spec.eventSchema),
+      errors: extractErrorDefs(A.Spec.errorSchema),
       chapter: componentChapters[A.Spec.name]
     };
   });
@@ -641,6 +653,9 @@ export {
   statusFieldFromStateSchema,
   labelFieldSourceToString,
   labelFieldsFromStateSchema,
+  toEventDef,
+  extractEventDefs,
+  extractErrorDefs,
   make,
 }
 /* log Not a pure module */

package/tests/ResourceAttributionTest.res

@@ -68,3 +68,118 @@ describe("ResourceAttribution — ambient plugin context", () => {
     expect(Attribution.current.contents.plugin)->toEqual(None)
   })
 })
+
+// The bracket only covers what runs synchronously inside a builder's construct.
+// Builders defer part of their work into a `Pulumi.Output.apply`, which runs
+// after `restore` has emptied the context — so a resource created there is
+// attributed to nobody. These pin the mechanism that carries the context across
+// that gap. Each empties the context first, which is exactly the state a
+// deferred callback finds itself in.
+
+describe("ResourceAttribution — carrying the context into deferred work", () => {
+  testSync("a deferred callback runs under the context it was wrapped in", () => {
+    let previous = Attribution.enter(~platform="online-shop", ~plugin="Catalog")
+    let observed = ref(None)
+    let finish = Attribution.deferred(() => observed := Attribution.current.contents.plugin)
+    Attribution.restore(previous)
+
+    // Construct has returned; nothing is attributed. This is when the apply fires.
+    expect(Attribution.current.contents.plugin)->toEqual(None)
+    finish()
+    expect(observed.contents)->toEqual(Some("Catalog"))
+  })
+
+  testSync("it puts the context back, so the next callback is not attributed to it", () => {
+    let previous = Attribution.enter(~platform="online-shop", ~plugin="Catalog")
+    let finish = Attribution.deferred(() => ())
+    Attribution.restore(previous)
+
+    finish()
+    expect(Attribution.current.contents.plugin)->toEqual(None)
+  })
+
+  // The registries these callbacks land in are module-level and shared, so one
+  // apply runs several plugins' finish functions back to back. Attributing them
+  // all to whichever ran first is the failure this guards.
+  testSync("two plugins deferred from one apply are each attributed to themselves", () => {
+    let outer = Attribution.enter(~platform="online-shop", ~plugin="Catalog")
+    let catalogSaw = ref(None)
+    let catalogFinish = Attribution.deferred(() =>
+      catalogSaw := Attribution.current.contents.plugin
+    )
+    Attribution.restore(outer)
+
+    let previous = Attribution.enter(~platform="online-shop", ~plugin="Ordering")
+    let orderingSaw = ref(None)
+    let orderingFinish = Attribution.deferred(() =>
+      orderingSaw := Attribution.current.contents.plugin
+    )
+    Attribution.restore(previous)
+
+    catalogFinish()
+    orderingFinish()
+    expect((catalogSaw.contents, orderingSaw.contents))->toEqual((
+      Some("Catalog"),
+      Some("Ordering"),
+    ))
+  })
+
+  testSync("a throwing callback still puts the context back", () => {
+    let previous = Attribution.enter(~platform="online-shop", ~plugin="Catalog")
+    let finish: unit => unit = Attribution.deferred(() =>
+      JsError.throwWithMessage("finish blew up")
+    )
+    Attribution.restore(previous)
+
+    let threw = try {
+      finish()
+      false
+    } catch {
+    | _ => true
+    }
+    expect(threw)->toBe(true)
+    expect(Attribution.current.contents.plugin)->toEqual(None)
+  })
+
+  testSync("within re-enters a captured context for a callback that takes arguments", () => {
+    let previous = Attribution.enter(~platform="online-shop", ~plugin="Catalog")
+    let captured = Attribution.current.contents
+    Attribution.restore(previous)
+
+    let observed = captured->Attribution.within(() => Attribution.current.contents.plugin)
+    expect(observed)->toEqual(Some("Catalog"))
+    expect(Attribution.current.contents.plugin)->toEqual(None)
+  })
+
+  testSync("enterCaptured can express the empty context, which enter cannot", () => {
+    let previous = Attribution.enter(~platform="online-shop", ~plugin="Catalog")
+    let restoredToEmpty = Attribution.enterCaptured({platform: None, plugin: None})
+    expect(Attribution.current.contents.plugin)->toEqual(None)
+    expect(restoredToEmpty.plugin)->toEqual(Some("Catalog"))
+    Attribution.restore(previous)
+  })
+})
+
+// The combinator being right is not the same as it being wired in. This one
+// exercises the production choke point: a task side-effect handler registered
+// during construct, then run the way `finishTasks` runs it — from an apply,
+// with nothing attributed.
+describe("Builder_Helpers.registerTaskSideEffectHandler — attribution survives the deferral", () => {
+  testSync("the registered finish sees the plugin that registered it", () => {
+    let before = Builder_Helpers.taskSideEffectFinishFns->Array.length
+    let observed = ref(None)
+
+    let previous = Attribution.enter(~platform="online-shop", ~plugin="Catalog")
+    Builder_Helpers.registerTaskSideEffectHandler(
+      ~gate=Pulumi.Output.make(),
+      ~finish=() => observed := Attribution.current.contents.plugin,
+    )
+    Attribution.restore(previous)
+
+    switch Builder_Helpers.taskSideEffectFinishFns->Array.get(before) {
+    | Some(finish) => finish()
+    | None => JsError.throwWithMessage("handler was not registered")
+    }
+    expect(observed.contents)->toEqual(Some("Catalog"))
+  })
+})

package/tests/ResourceAttributionTest.res.mjs

@@ -1,6 +1,9 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Pulumi from "@pulumi/pulumi";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as ComponentType$ReventlessCore from "../src/ComponentType.res.mjs";
+import * as Builder_Helpers$ReventlessCore from "../src/components/Builder_Helpers.res.mjs";
 import * as ResourceAttribution$ReventlessCore from "../src/ResourceAttribution.res.mjs";
 
 globalThis.describe("ResourceAttribution.Scope — wire spellings", () => {
@@ -67,6 +70,109 @@ globalThis.describe("ResourceAttribution — ambient plugin context", () => {
   });
 });
 
+globalThis.describe("ResourceAttribution — carrying the context into deferred work", () => {
+  globalThis.test("a deferred callback runs under the context it was wrapped in", () => {
+    let previous = ResourceAttribution$ReventlessCore.enter("online-shop", "Catalog");
+    let observed = {
+      contents: undefined
+    };
+    let finish = ResourceAttribution$ReventlessCore.deferred(() => {
+      observed.contents = ResourceAttribution$ReventlessCore.current.contents.plugin;
+    });
+    ResourceAttribution$ReventlessCore.restore(previous);
+    globalThis.expect(ResourceAttribution$ReventlessCore.current.contents.plugin).toEqual(undefined);
+    finish();
+    globalThis.expect(observed.contents).toEqual("Catalog");
+  });
+  globalThis.test("it puts the context back, so the next callback is not attributed to it", () => {
+    let previous = ResourceAttribution$ReventlessCore.enter("online-shop", "Catalog");
+    let finish = ResourceAttribution$ReventlessCore.deferred(() => {});
+    ResourceAttribution$ReventlessCore.restore(previous);
+    finish();
+    globalThis.expect(ResourceAttribution$ReventlessCore.current.contents.plugin).toEqual(undefined);
+  });
+  globalThis.test("two plugins deferred from one apply are each attributed to themselves", () => {
+    let outer = ResourceAttribution$ReventlessCore.enter("online-shop", "Catalog");
+    let catalogSaw = {
+      contents: undefined
+    };
+    let catalogFinish = ResourceAttribution$ReventlessCore.deferred(() => {
+      catalogSaw.contents = ResourceAttribution$ReventlessCore.current.contents.plugin;
+    });
+    ResourceAttribution$ReventlessCore.restore(outer);
+    let previous = ResourceAttribution$ReventlessCore.enter("online-shop", "Ordering");
+    let orderingSaw = {
+      contents: undefined
+    };
+    let orderingFinish = ResourceAttribution$ReventlessCore.deferred(() => {
+      orderingSaw.contents = ResourceAttribution$ReventlessCore.current.contents.plugin;
+    });
+    ResourceAttribution$ReventlessCore.restore(previous);
+    catalogFinish();
+    orderingFinish();
+    globalThis.expect([
+      catalogSaw.contents,
+      orderingSaw.contents
+    ]).toEqual([
+      "Catalog",
+      "Ordering"
+    ]);
+  });
+  globalThis.test("a throwing callback still puts the context back", () => {
+    let previous = ResourceAttribution$ReventlessCore.enter("online-shop", "Catalog");
+    let finish = ResourceAttribution$ReventlessCore.deferred(() => Stdlib_JsError.throwWithMessage("finish blew up"));
+    ResourceAttribution$ReventlessCore.restore(previous);
+    let threw;
+    try {
+      finish();
+      threw = false;
+    } catch (exn) {
+      threw = true;
+    }
+    globalThis.expect(threw).toBe(true);
+    globalThis.expect(ResourceAttribution$ReventlessCore.current.contents.plugin).toEqual(undefined);
+  });
+  globalThis.test("within re-enters a captured context for a callback that takes arguments", () => {
+    let previous = ResourceAttribution$ReventlessCore.enter("online-shop", "Catalog");
+    let captured = ResourceAttribution$ReventlessCore.current.contents;
+    ResourceAttribution$ReventlessCore.restore(previous);
+    let observed = ResourceAttribution$ReventlessCore.within(captured, () => ResourceAttribution$ReventlessCore.current.contents.plugin);
+    globalThis.expect(observed).toEqual("Catalog");
+    globalThis.expect(ResourceAttribution$ReventlessCore.current.contents.plugin).toEqual(undefined);
+  });
+  globalThis.test("enterCaptured can express the empty context, which enter cannot", () => {
+    let previous = ResourceAttribution$ReventlessCore.enter("online-shop", "Catalog");
+    let restoredToEmpty = ResourceAttribution$ReventlessCore.enterCaptured({
+      platform: undefined,
+      plugin: undefined
+    });
+    globalThis.expect(ResourceAttribution$ReventlessCore.current.contents.plugin).toEqual(undefined);
+    globalThis.expect(restoredToEmpty.plugin).toEqual("Catalog");
+    ResourceAttribution$ReventlessCore.restore(previous);
+  });
+});
+
+globalThis.describe("Builder_Helpers.registerTaskSideEffectHandler — attribution survives the deferral", () => {
+  globalThis.test("the registered finish sees the plugin that registered it", () => {
+    let before = Builder_Helpers$ReventlessCore.taskSideEffectFinishFns.length;
+    let observed = {
+      contents: undefined
+    };
+    let previous = ResourceAttribution$ReventlessCore.enter("online-shop", "Catalog");
+    Builder_Helpers$ReventlessCore.registerTaskSideEffectHandler(Pulumi.output(), () => {
+      observed.contents = ResourceAttribution$ReventlessCore.current.contents.plugin;
+    });
+    ResourceAttribution$ReventlessCore.restore(previous);
+    let finish = Builder_Helpers$ReventlessCore.taskSideEffectFinishFns[before];
+    if (finish !== undefined) {
+      finish();
+    } else {
+      Stdlib_JsError.throwWithMessage("handler was not registered");
+    }
+    globalThis.expect(observed.contents).toEqual("Catalog");
+  });
+});
+
 let Attribution;
 
 export {

package/tests/adapter/QueryInterceptionTest.res

@@ -0,0 +1,55 @@
+open JestGlobals
+
+// The seam is a single process-global switch, so what is worth pinning is the
+// default (off) and the fact that switching it on does not also register a
+// runtime interceptor — the two are deliberately separate decisions, and
+// conflating them would provision an interceptor path for a hook nobody set.
+
+module Interception = QueryInterception
+
+describe("QueryInterception", () => {
+  testSync("off by default — no registration, nothing provisioned", () => {
+    Interception.reset()
+    expect(Interception.isEnabled())->toBe(false)
+  })
+
+  testSync("use switches it on for the deployment", () => {
+    Interception.reset()
+    Interception.use()
+    expect(Interception.isEnabled())->toBe(true)
+    Interception.reset()
+  })
+
+  testSync("use is idempotent — an extension may call it more than once", () => {
+    Interception.reset()
+    Interception.use()
+    Interception.use()
+    expect(Interception.isEnabled())->toBe(true)
+    Interception.reset()
+  })
+
+  testSync("reset puts it back, so one test cannot leak into the next", () => {
+    Interception.use()
+    Interception.reset()
+    expect(Interception.isEnabled())->toBe(false)
+  })
+
+  // Provisioning the path and registering the hook are separate on purpose: the
+  // framework provisions, the extension decides what runs. Asking for
+  // interception must not fabricate an interceptor.
+  testSync("switching provisioning on does not register a runtime interceptor", () => {
+    QueryDb_Callback.clearQueryInterceptor()
+    Interception.use()
+    expect(QueryDb_Callback.queryInterceptorHook.contents->Option.isNone)->toBe(true)
+    Interception.reset()
+  })
+
+  testSync("and registering a runtime interceptor does not switch provisioning on", () => {
+    Interception.reset()
+    QueryDb_Callback.registerQueryInterceptor((~identity as _, ~readModelName as _, ~args as _) =>
+      Promise.resolve(QueryDb_Callback.Allow)
+    )
+    expect(Interception.isEnabled())->toBe(false)
+    QueryDb_Callback.clearQueryInterceptor()
+  })
+})

package/tests/adapter/QueryInterceptionTest.res.mjs

@@ -0,0 +1,49 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as QueryDb_Callback$ReventlessCore from "../../src/components/QueryDb/QueryDb_Callback.res.mjs";
+import * as QueryInterception$ReventlessCore from "../../src/adapter/QueryInterception/QueryInterception.res.mjs";
+
+globalThis.describe("QueryInterception", () => {
+  globalThis.test("off by default — no registration, nothing provisioned", () => {
+    QueryInterception$ReventlessCore.reset();
+    globalThis.expect(QueryInterception$ReventlessCore.isEnabled()).toBe(false);
+  });
+  globalThis.test("use switches it on for the deployment", () => {
+    QueryInterception$ReventlessCore.reset();
+    QueryInterception$ReventlessCore.use();
+    globalThis.expect(QueryInterception$ReventlessCore.isEnabled()).toBe(true);
+    QueryInterception$ReventlessCore.reset();
+  });
+  globalThis.test("use is idempotent — an extension may call it more than once", () => {
+    QueryInterception$ReventlessCore.reset();
+    QueryInterception$ReventlessCore.use();
+    QueryInterception$ReventlessCore.use();
+    globalThis.expect(QueryInterception$ReventlessCore.isEnabled()).toBe(true);
+    QueryInterception$ReventlessCore.reset();
+  });
+  globalThis.test("reset puts it back, so one test cannot leak into the next", () => {
+    QueryInterception$ReventlessCore.use();
+    QueryInterception$ReventlessCore.reset();
+    globalThis.expect(QueryInterception$ReventlessCore.isEnabled()).toBe(false);
+  });
+  globalThis.test("switching provisioning on does not register a runtime interceptor", () => {
+    QueryDb_Callback$ReventlessCore.clearQueryInterceptor();
+    QueryInterception$ReventlessCore.use();
+    globalThis.expect(Stdlib_Option.isNone(QueryDb_Callback$ReventlessCore.queryInterceptorHook.contents)).toBe(true);
+    QueryInterception$ReventlessCore.reset();
+  });
+  globalThis.test("and registering a runtime interceptor does not switch provisioning on", () => {
+    QueryInterception$ReventlessCore.reset();
+    QueryDb_Callback$ReventlessCore.registerQueryInterceptor((param, param$1, param$2) => Promise.resolve("Allow"));
+    globalThis.expect(QueryInterception$ReventlessCore.isEnabled()).toBe(false);
+    QueryDb_Callback$ReventlessCore.clearQueryInterceptor();
+  });
+});
+
+let Interception;
+
+export {
+  Interception,
+}
+/*  Not a pure module */

package/tests/admin/Platform_ComponentDefinitionsApiTest.res

@@ -41,6 +41,7 @@ let wbl: writableDef = {
   producedEventTypes: ["ProductAdded"],
   consumedEventTypes: [],
   events: [{name: "ProductAdded", schema: "{}", references: []}],
+  errors: [{name: "ProductAlreadyExists", schema: "{}", references: []}],
   chapter: None,
 }
 
@@ -162,6 +163,17 @@ describe("encodePluginStructureEntry", () => {
     expect(json->String.includes("\"events\":[{\"name\":\"ProductAdded\""))->toEqual(true)
   )
 
+  // The refusals a caller has to handle travel beside the facts it can observe.
+  testSync("encodes writableDef errors", () =>
+    expect(json->String.includes("\"errors\":[{\"name\":\"ProductAlreadyExists\""))->toEqual(true)
+  )
+
+  testSync("declares Platform_ErrorDef and the errors field in the shared write-side SDL", () => {
+    let sdl = Platform_ComponentDefinitionsApi.sdlTypes->Array.join("\n")
+    expect(sdl->String.includes("type Platform_ErrorDef"))->toEqual(true)
+    expect(sdl->String.includes("errors: [Platform_ErrorDef!]!"))->toEqual(true)
+  })
+
   // Translation-slice externalSystem: absent on the fixture above (both None), so it
   // must serialize as null — the "no external box" case. The leading field keeps the
   // two directions apart; `targetName` sits between them and is pinned here too.
@@ -292,6 +304,7 @@ describe("allowedStates + statusField populated", () => {
     producedEventTypes: [],
     consumedEventTypes: [],
     events: [],
+    errors: [],
     chapter: None,
   }
 
@@ -325,4 +338,12 @@ describe("allowedStates + statusField populated", () => {
   testSync("encodes populated statusField as the field name string", () =>
     expect(json->String.includes("\"statusField\":\"status\""))->toEqual(true)
   )
+
+  // "declares no errors" is an empty list, never null — the SDL types `errors` as
+  // non-null, and a structure is re-derived on every build, so there is no third
+  // "cannot say" state to encode.
+  testSync("encodes a component with no declared errors as an empty array, not null", () => {
+    expect(json->String.includes("\"errors\":[]"))->toEqual(true)
+    expect(json->String.includes("\"errors\":null"))->toEqual(false)
+  })
 })

package/tests/admin/Platform_ComponentDefinitionsApiTest.res.mjs

@@ -61,6 +61,12 @@ let wbl_events = [{
     references: []
   }];
 
+let wbl_errors = [{
+    name: "ProductAlreadyExists",
+    schema: "{}",
+    references: []
+  }];
+
 let wbl = {
   name: "Product",
   commands: wbl_commands,
@@ -69,6 +75,7 @@ let wbl = {
   linkedViews: wbl_linkedViews,
   consistencyRead: undefined,
   events: wbl_events,
+  errors: wbl_errors,
   chapter: undefined
 };
 
@@ -182,6 +189,14 @@ globalThis.describe("encodePluginStructureEntry", () => {
   globalThis.test("encodes writableDef events", () => {
     globalThis.expect(json.includes("\"events\":[{\"name\":\"ProductAdded\"")).toEqual(true);
   });
+  globalThis.test("encodes writableDef errors", () => {
+    globalThis.expect(json.includes("\"errors\":[{\"name\":\"ProductAlreadyExists\"")).toEqual(true);
+  });
+  globalThis.test("declares Platform_ErrorDef and the errors field in the shared write-side SDL", () => {
+    let sdl = Platform_ComponentDefinitionsApi$ReventlessCore.sdlTypes.join("\n");
+    globalThis.expect(sdl.includes("type Platform_ErrorDef")).toEqual(true);
+    globalThis.expect(sdl.includes("errors: [Platform_ErrorDef!]!")).toEqual(true);
+  });
   globalThis.test("encodes None outbound externalSystem as null", () => {
     globalThis.expect(json.includes("\"inboundCommandTypes\":[\"Ship\"],\"targetName\":null,\"externalSystem\":null")).toEqual(true);
   });
@@ -326,6 +341,7 @@ globalThis.describe("allowedStates + statusField populated", () => {
   let wblWithStates_consumedEventTypes = [];
   let wblWithStates_linkedViews = ["Plugin"];
   let wblWithStates_events = [];
+  let wblWithStates_errors = [];
   let wblWithStates = {
     name: "Plugin",
     commands: wblWithStates_commands,
@@ -334,6 +350,7 @@ globalThis.describe("allowedStates + statusField populated", () => {
     linkedViews: wblWithStates_linkedViews,
     consistencyRead: undefined,
     events: wblWithStates_events,
+    errors: wblWithStates_errors,
     chapter: undefined
   };
   let structureWithStates_readModels = [qblWithStatus];
@@ -367,6 +384,10 @@ globalThis.describe("allowedStates + statusField populated", () => {
   globalThis.test("encodes populated statusField as the field name string", () => {
     globalThis.expect(json.includes("\"statusField\":\"status\"")).toEqual(true);
   });
+  globalThis.test("encodes a component with no declared errors as an empty array, not null", () => {
+    globalThis.expect(json.includes("\"errors\":[]")).toEqual(true);
+    globalThis.expect(json.includes("\"errors\":null")).toEqual(false);
+  });
 });
 
 export {