@reventlessdev/reventless-core 3.0.0-alpha.134

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

@@ -0,0 +1,458 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Belt_SetString from "@rescript/runtime/lib/es6/Belt_SetString.js";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Reference$Reventless from "@reventlessdev/reventless-spec/src/components/Reference.res.mjs";
+import * as Logger$ReventlessCore from "../../util/Logger.res.mjs";
+import * as DisplayName$Reventless from "@reventlessdev/reventless-spec/src/components/DisplayName.res.mjs";
+import * as Api_Naming$ReventlessCore from "../../components/Api/Api_Naming.res.mjs";
+import * as StateAnnotations$Reventless from "@reventlessdev/reventless-spec/src/components/StateAnnotations.res.mjs";
+import * as ApiNoApiHelpers$ReventlessCore from "../../components/Api/ApiNoApiHelpers.res.mjs";
+import * as SuryToJsonSchema$ReventlessCore from "../../components/Api/SuryToJsonSchema.res.mjs";
+import * as ApiAllowedStatesHelpers$ReventlessCore from "../../components/Api/ApiAllowedStatesHelpers.res.mjs";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+function isIdLikeFieldName(name) {
+  if (name === "id" || name.endsWith("Id")) {
+    return true;
+  } else {
+    return name.endsWith("Ids");
+  }
+}
+
+function statusFieldFromStateSchema(stateSchema) {
+  let spec = StateAnnotations$Reventless.getSpec(stateSchema);
+  let annotated = spec !== undefined ? spec.status : undefined;
+  if (annotated !== undefined) {
+    return annotated;
+  } else if (stateSchema.type === "object") {
+    return Stdlib_Option.map(stateSchema.items.find(item => item.location === "status"), item => item.location);
+  } else {
+    return;
+  }
+}
+
+function labelFieldsFromStateSchema(entityName, stateSchema) {
+  let spec = DisplayName$Reventless.getSpec(stateSchema);
+  if (spec !== undefined) {
+    return [
+      "displayName",
+      spec.fields
+    ];
+  }
+  let firstStringItem;
+  firstStringItem = stateSchema.type === "object" ? stateSchema.items.find(item => {
+      if (item.location === "TAG" || isIdLikeFieldName(item.location)) {
+        return false;
+      }
+      let match = item.schema;
+      return match.type === "string";
+    }) : undefined;
+  if (firstStringItem !== undefined) {
+    return [
+      firstStringItem.location,
+      [firstStringItem.location]
+    ];
+  } else {
+    log.warn("Plugin_Structure", undefined, entityName + `: no @displayName annotation and no suitable string field — labelField falls back to "id"`);
+    return [
+      "id",
+      []
+    ];
+  }
+}
+
+function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChangeSlicesOpt, automationSlicesOpt, outboundTranslationSlicesOpt, inboundTranslationSlicesOpt, extensionsOpt, extensionPointsOpt) {
+  let aggregates = aggregatesOpt !== undefined ? aggregatesOpt : [];
+  let readModels = readModelsOpt !== undefined ? readModelsOpt : [];
+  let stateViewSlices = stateViewSlicesOpt !== undefined ? stateViewSlicesOpt : [];
+  let stateChangeSlices = stateChangeSlicesOpt !== undefined ? stateChangeSlicesOpt : [];
+  let automationSlices = automationSlicesOpt !== undefined ? automationSlicesOpt : [];
+  let outboundTranslationSlices = outboundTranslationSlicesOpt !== undefined ? outboundTranslationSlicesOpt : [];
+  let inboundTranslationSlices = inboundTranslationSlicesOpt !== undefined ? inboundTranslationSlicesOpt : [];
+  let extensions = extensionsOpt !== undefined ? extensionsOpt : [];
+  let extensionPoints = extensionPointsOpt !== undefined ? extensionPointsOpt : [];
+  let qualify = (prefix, names) => names.map(n => prefix + "." + n);
+  let isCreateCommandName = name => [
+    "Add",
+    "Create",
+    "Register",
+    "Open",
+    "Initialize",
+    "Submit",
+    "Start",
+    "Place"
+  ].some(p => name.startsWith(p));
+  let commandLevelAndId = (isAggregate, variantName, properties) => {
+    if (isAggregate) {
+      if (isCreateCommandName(variantName)) {
+        return [
+          "Collection",
+          undefined
+        ];
+      } else {
+        return [
+          "Instance",
+          undefined
+        ];
+      }
+    }
+    let taggedFields = Object.entries(properties).filter(param => {
+      let fieldSchema = param[1];
+      if (param[0] !== "TAG") {
+        if (DcbTag$Reventless.isTagged(fieldSchema)) {
+          return true;
+        } else {
+          return DcbTag$Reventless.isTaggedArray(fieldSchema);
+        }
+      } else {
+        return false;
+      }
+    });
+    let taggedField = Stdlib_Option.orElse(taggedFields.find(param => DcbTag$Reventless.isPartitionTag(param[1])), taggedFields[0]);
+    if (taggedField === undefined) {
+      return [
+        "Collection",
+        undefined
+      ];
+    }
+    let fieldName = taggedField[0];
+    if (isCreateCommandName(variantName)) {
+      return [
+        "Collection",
+        fieldName
+      ];
+    } else {
+      return [
+        "Instance",
+        fieldName
+      ];
+    }
+  };
+  let toCommandDef = (isAggregate, mutationFieldFor, parentSchema, v) => {
+    let mkDef = (variantName, properties) => {
+      let match = commandLevelAndId(isAggregate, 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
+        }));
+      });
+      let allowedStates = ApiAllowedStatesHelpers$ReventlessCore.getAllowedStates(parentSchema, variantName);
+      let apiExposed = false;
+      if (!ApiNoApiHelpers$ReventlessCore.isNoApi(parentSchema)) {
+        let excluded = ApiNoApiHelpers$ReventlessCore.getExcludedVariants(parentSchema);
+        apiExposed = excluded !== undefined ? !excluded.has(variantName) : true;
+      }
+      return {
+        name: variantName,
+        schema: JSON.stringify(S.toJSONSchema(v)),
+        level: match[0],
+        aggregateIdField: match[1],
+        mutationField: mutationFieldFor(variantName),
+        references: references,
+        allowedStates: allowedStates,
+        apiExposed: apiExposed
+      };
+    };
+    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 extractCommandDefs = (isAggregate, mutationFieldFor, commandSchema) => {
+    if (commandSchema.type === "union") {
+      return Stdlib_Array.filterMap(commandSchema.anyOf, v => toCommandDef(isAggregate, mutationFieldFor, commandSchema, v));
+    } else {
+      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(S.toJSONSchema(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))
+  ]);
+  let scsConsumed = stateChangeSlices.map(SCS => [
+    SCS.Spec.name,
+    qualify(name, DcbTag$Reventless.extractVariantNames(SCS.Spec.consumedEventSchema))
+  ]);
+  let aggProduced = aggregates.map(A => [
+    A.Spec.name,
+    qualify(name, DcbTag$Reventless.extractVariantNames(A.Spec.eventSchema))
+  ]);
+  let svsConsumed = stateViewSlices.map(SVS => [
+    SVS.Spec.name,
+    qualify(name, DcbTag$Reventless.extractVariantNames(SVS.Spec.consumedEventSchema))
+  ]);
+  let rmSourceNames = readModels.map(R => [
+    R.Spec.name,
+    R.sourceNames
+  ]);
+  let allWritableProduced = scsProduced.concat(aggProduced);
+  let intersects = (a, b) => a.some(x => b.includes(x));
+  let linkedSvsFor = producedTypes => Stdlib_Array.filterMap(svsConsumed, param => {
+    if (intersects(producedTypes, param[1])) {
+      return param[0];
+    }
+  });
+  let linkedReadModelsFor = aggregateName => Stdlib_Array.filterMap(rmSourceNames, param => {
+    if (param[1].includes(aggregateName)) {
+      return param[0];
+    }
+  });
+  let linkedWriteSideFor = consumedTypes => Stdlib_Array.filterMap(allWritableProduced, param => {
+    if (intersects(consumedTypes, param[1])) {
+      return param[0];
+    }
+  });
+  let consistencyReadFor = scsConsumedTypes => {
+    let scored = svsConsumed.map(param => {
+      let consumed = param[1];
+      let overlap = consumed.filter(e => scsConsumedTypes.includes(e)).length;
+      let total = consumed.length;
+      return [
+        param[0],
+        overlap,
+        total
+      ];
+    }).filter(param => param[1] > 0).toSorted((param, param$1) => {
+      let cmp = Primitive_int.compare(param$1[1], param[1]);
+      if (cmp !== 0) {
+        return cmp;
+      } else {
+        return Primitive_int.compare(param$1[2], param[2]);
+      }
+    });
+    let match = scored.length;
+    if (match === 0) {
+      return;
+    }
+    if (match !== 1) {
+      let match$1 = scored[0];
+      let top = match$1[1];
+      let viewName = match$1[0];
+      let match$2 = scored[1];
+      let second = match$2[1];
+      if (top > second || top === second && match$1[2] > match$2[2]) {
+        return viewName;
+      } else {
+        return;
+      }
+    }
+    let match$3 = scored[0];
+    return match$3[0];
+  };
+  let visibilityTag = v => {
+    if (v === "Public") {
+      return;
+    } else {
+      return "Internal";
+    }
+  };
+  let readModelDefs = readModels.map(R => {
+    let qf = Api_Naming$ReventlessCore.queryFieldNamesForReadModel(name, R.Spec.name, undefined);
+    let stateSchema = R.Spec.stateSchema;
+    let match = labelFieldsFromStateSchema(R.Spec.name, stateSchema);
+    return {
+      name: R.Spec.name,
+      queryField: qf.listFieldName,
+      schema: JSON.stringify(SuryToJsonSchema$ReventlessCore.deriveObjectSchema(stateSchema)),
+      consumedEventTypes: [],
+      linkedWriteSide: [],
+      labelField: match[0],
+      searchableFields: match[1],
+      statusField: statusFieldFromStateSchema(stateSchema),
+      visibility: visibilityTag(R.Spec.visibility)
+    };
+  });
+  let stateViewDefs = stateViewSlices.map((SVS, i) => {
+    let qf = Api_Naming$ReventlessCore.queryFieldNamesForStateView(name, SVS.Spec.name, undefined);
+    let match = svsConsumed[i];
+    let consumed = match[1];
+    let stateSchema = SVS.Spec.stateSchema;
+    let match$1 = labelFieldsFromStateSchema(SVS.Spec.name, stateSchema);
+    return {
+      name: SVS.Spec.name,
+      queryField: qf.listFieldName,
+      schema: JSON.stringify(SuryToJsonSchema$ReventlessCore.deriveObjectSchema(stateSchema)),
+      consumedEventTypes: consumed,
+      linkedWriteSide: linkedWriteSideFor(consumed),
+      labelField: match$1[0],
+      searchableFields: match$1[1],
+      statusField: statusFieldFromStateSchema(stateSchema),
+      visibility: visibilityTag(SVS.Spec.visibility)
+    };
+  });
+  let stateChangeDefs = stateChangeSlices.map((SCS, i) => {
+    let match = scsProduced[i];
+    let produced = match[1];
+    let match$1 = scsConsumed[i];
+    let consumed = match$1[1];
+    return {
+      name: SCS.Spec.name,
+      commands: extractCommandDefs(false, _variantName => Api_Naming$ReventlessCore.sliceMutationField(name, SCS.Spec.name), SCS.Spec.commandSchema),
+      producedEventTypes: produced,
+      consumedEventTypes: consumed,
+      linkedViews: linkedSvsFor(produced),
+      consistencyRead: consistencyReadFor(consumed),
+      events: extractEventDefs(SCS.Spec.eventSchema)
+    };
+  });
+  let aggregateDefs = aggregates.map((A, i) => {
+    let match = aggProduced[i];
+    let produced = match[1];
+    return {
+      name: A.Spec.name,
+      commands: extractCommandDefs(true, variantName => Api_Naming$ReventlessCore.aggregateMutationField(name, A.Spec.name, variantName), A.Spec.commandSchema),
+      producedEventTypes: produced,
+      consumedEventTypes: [],
+      linkedViews: linkedSvsFor(produced).concat(linkedReadModelsFor(A.Spec.name)),
+      consistencyRead: undefined,
+      events: extractEventDefs(A.Spec.eventSchema)
+    };
+  });
+  let automationSliceDefs = automationSlices.map(AS => {
+    let allConsumedVariants = Belt_SetString.toArray(Belt_SetString.fromArray(AS.Automation.mappings.flatMap(M => DcbTag$Reventless.extractVariantNames(M.sourceEventSchema))));
+    return {
+      name: AS.Spec.name,
+      consumedEventTypes: qualify(name, allConsumedVariants),
+      producedCommandTypes: qualify(name, DcbTag$Reventless.extractAllVariantNames(AS.Spec.commandSchema)),
+      targetName: AS.Spec.targetName
+    };
+  });
+  let outboundTranslationSliceDefs = outboundTranslationSlices.map(OTS => ({
+    name: OTS.Spec.name,
+    consumedEventTypes: qualify(name, DcbTag$Reventless.extractVariantNames(OTS.Spec.consumedEventSchema)),
+    inboundCommandTypes: qualify(name, DcbTag$Reventless.extractAllVariantNames(OTS.Spec.inboundCommandSchema)),
+    targetName: OTS.Spec.targetName
+  }));
+  let inboundTranslationSliceDefs = inboundTranslationSlices.map(ITS => ({
+    name: ITS.Spec.name,
+    commandTypes: qualify(name, DcbTag$Reventless.extractAllVariantNames(ITS.Spec.commandSchema)),
+    targetName: ITS.Spec.targetName
+  }));
+  let extensionDefs = extensions.map(E => {
+    let delegateNames = E.mappings.map(M => M.delegateName);
+    return {
+      name: E.Spec.name,
+      delegateNames: delegateNames,
+      eventTypes: qualify(E.Spec.name, DcbTag$Reventless.extractVariantNames(E.Spec.eventSchema)),
+      commandTypes: qualify(E.Spec.name, DcbTag$Reventless.extractAllVariantNames(E.Spec.commandSchema))
+    };
+  });
+  let epByName = {};
+  extensionPoints.forEach(M => {
+    let epName = M.ExtensionPoint.name;
+    let sourceEvents = qualify(name, DcbTag$Reventless.extractVariantNames(M.Delegate.eventSchema));
+    let commands = qualify(epName, DcbTag$Reventless.extractAllVariantNames(M.ExtensionPoint.commandSchema));
+    let match = Stdlib_Option.getOr(epByName[epName], [
+      [],
+      [],
+      []
+    ]);
+    epByName[epName] = [
+      match[0].concat([M.Delegate.name]),
+      match[1].concat(sourceEvents),
+      match[2].concat(commands)
+    ];
+  });
+  let extensionPointDefs = Object.entries(epByName).map(param => {
+    let match = param[1];
+    return {
+      name: param[0],
+      delegateNames: Belt_SetString.toArray(Belt_SetString.fromArray(match[0])),
+      sourceEventTypes: Belt_SetString.toArray(Belt_SetString.fromArray(match[1])),
+      commandTypes: Belt_SetString.toArray(Belt_SetString.fromArray(match[2]))
+    };
+  });
+  return {
+    readModels: readModelDefs,
+    stateViewSlices: stateViewDefs,
+    stateChangeSlices: stateChangeDefs,
+    aggregates: aggregateDefs,
+    automationSlices: automationSliceDefs,
+    outboundTranslationSlices: outboundTranslationSliceDefs,
+    inboundTranslationSlices: inboundTranslationSliceDefs,
+    extensions: extensionDefs,
+    extensionPoints: extensionPointDefs
+  };
+}
+
+export {
+  log,
+  isIdLikeFieldName,
+  statusFieldFromStateSchema,
+  labelFieldsFromStateSchema,
+  make,
+}
+/* log Not a pure module */

package/src/plugin/component/Plugin_SubscriptionSchema.res

@@ -0,0 +1,103 @@
+// Plugin_SubscriptionSchema.res
+// Generates subscription SDL fields and supporting types for a plugin.
+// Called by Plugin_Builder after generateFragment to inject subscriptions into
+// the fragment before it is pushed to the API and stored in the plugin definition.
+
+open ReventlessInfra.Api
+
+// ── Source C: mutation-triggered subscriptions ────────────────────────────────
+// One field per command variant. Fires when the mutation is ACCEPTED by AppSync.
+// Uses @aws_subscribe — no additional infrastructure is needed.
+//
+// Generated from the same mutation entries as the query/mutation SDL so that
+// field names and argument types are always in sync.
+
+// AppSync subscriptions have a hard limit of 5 input arguments.
+// Source C subscriptions only use `id` for server-side filtering (ctx.args.id),
+// so all subscription fields are generated with a single optional `id: ID` arg
+// regardless of how many args the corresponding mutation carries.
+//
+// Every aggregate-derived mutation now returns CommandResult (a union of
+// CommandAccepted | CommandRejected | CommandPending). AppSync requires the
+// subscription return type to be a strict subset of the linked mutation's
+// return type, so the subscription field has to declare CommandResult as well.
+let sourceCFields = (
+  ~mutationEntries: array<mutationSchemaEntry>,
+): array<string> => {
+  let fields: array<string> = []
+  mutationEntries->Array.forEach(entry => {
+    let schema = entry.commandSchema
+    switch schema {
+    | Union({anyOf}) =>
+      anyOf->Array.forEachWithIndex((_, i) => {
+        let fieldName = entry.fieldNames->Array.get(i)->Option.getOr("")
+        if fieldName->String.length > 0 {
+          let sub = `  on${fieldName}(id: ID): CommandResult\n    @aws_subscribe(mutations: ["${fieldName}"])`
+          fields->Array.push(sub)
+        }
+      })
+    | Object(_) =>
+      let fieldName = entry.fieldNames->Array.get(0)->Option.getOr("")
+      if fieldName->String.length > 0 {
+        let sub = `  on${fieldName}(id: ID): CommandResult\n    @aws_subscribe(mutations: ["${fieldName}"])`
+        fields->Array.push(sub)
+      }
+    | _ => ()
+    }
+  })
+  fields
+}
+
+// ── Source B: state-change subscriptions ─────────────────────────────────────
+// State changes are pushed directly via AppSync Events channels (one channel
+// per QueryDb row), not through a GraphQL Subscription field. Clients open a
+// WebSocket against the Events API endpoint and subscribe to a channel pattern
+// like `/default/{topicRoot}/{entityKey}` (or `/default/{topicRoot}/*` for a
+// list view). No SDL is generated here — see `StateTopic_AppSync.res` for the
+// publish path.
+
+// ── Source A: raw event stream subscriptions ──────────────────────────────────
+// One field per EventLog (aggregate or DCB). Fires when an event is appended.
+// Pushed via AppSync Events API. Admin / observability only.
+//
+// Returns (subscriptionFields, supportingTypes) — the supporting type is the
+// {DisplayName}EventLogEvent type that carries position, eventType, payload, and
+// the optional originatorSlice tag injected by StateChangeSlice_Callback.
+
+let sourceAFieldsAndTypes = (
+  ~eventLogEntries: array<eventLogSchemaEntry>,
+): (array<string>, array<string>) => {
+  let seen: Set.t<string> = Set.make()
+  let fields: array<string> = []
+  let types: array<string> = []
+  eventLogEntries->Array.forEach(entry => {
+    let n = entry.displayName
+    if !(seen->Set.has(n)) {
+      seen->Set.add(n)
+      fields->Array.push(`  on${n}EventLog_eventAppended: ${n}EventLogEvent`)
+      types->Array.push(
+        `type ${n}EventLogEvent {\n  position: String!\n  eventType: String!\n  payload: AWSJSON!\n  originatorSlice: String\n}`,
+      )
+    }
+  })
+  (fields, types)
+}
+
+// ── Public API ────────────────────────────────────────────────────────────────
+
+type result = {
+  subscriptionFields: array<string>,
+  extraTypes: array<string>,
+}
+
+let generate = (
+  ~mutationEntries: array<mutationSchemaEntry>,
+  ~eventLogEntries: array<eventLogSchemaEntry>,
+): result => {
+  let cFields = sourceCFields(~mutationEntries)
+  let (aFields, aTypes) = sourceAFieldsAndTypes(~eventLogEntries)
+  {
+    subscriptionFields: Array.flat([cFields, aFields]),
+    extraTypes: aTypes,
+  }
+}

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

@@ -0,0 +1,71 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+function sourceCFields(mutationEntries) {
+  let fields = [];
+  mutationEntries.forEach(entry => {
+    let schema = entry.commandSchema;
+    switch (schema.type) {
+      case "object" :
+        let fieldName = Stdlib_Option.getOr(entry.fieldNames[0], "");
+        if (fieldName.length <= 0) {
+          return;
+        }
+        let sub = `  on` + fieldName + `(id: ID): CommandResult\n    @aws_subscribe(mutations: ["` + fieldName + `"])`;
+        fields.push(sub);
+        return;
+      case "union" :
+        schema.anyOf.forEach((param, i) => {
+          let fieldName = Stdlib_Option.getOr(entry.fieldNames[i], "");
+          if (fieldName.length <= 0) {
+            return;
+          }
+          let sub = `  on` + fieldName + `(id: ID): CommandResult\n    @aws_subscribe(mutations: ["` + fieldName + `"])`;
+          fields.push(sub);
+        });
+        return;
+      default:
+        return;
+    }
+  });
+  return fields;
+}
+
+function sourceAFieldsAndTypes(eventLogEntries) {
+  let seen = new Set();
+  let fields = [];
+  let types = [];
+  eventLogEntries.forEach(entry => {
+    let n = entry.displayName;
+    if (!seen.has(n)) {
+      seen.add(n);
+      fields.push(`  on` + n + `EventLog_eventAppended: ` + n + `EventLogEvent`);
+      types.push(`type ` + n + `EventLogEvent {\n  position: String!\n  eventType: String!\n  payload: AWSJSON!\n  originatorSlice: String\n}`);
+      return;
+    }
+  });
+  return [
+    fields,
+    types
+  ];
+}
+
+function generate(mutationEntries, eventLogEntries) {
+  let cFields = sourceCFields(mutationEntries);
+  let match = sourceAFieldsAndTypes(eventLogEntries);
+  return {
+    subscriptionFields: [
+      cFields,
+      match[0]
+    ].flat(),
+    extraTypes: match[1]
+  };
+}
+
+export {
+  sourceCFields,
+  sourceAFieldsAndTypes,
+  generate,
+}
+/* No side effect */