@reventlessdev/reventless-aws 3.0.0-alpha.167

package/src/adapter/Mcp/MCP_Lambda.res.mjs

@@ -0,0 +1,289 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Stream$1 from "effect/Stream";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as AWS$ReventlessAws from "../AWS.res.mjs";
+import * as Identity$Reventless from "@reventlessdev/reventless-spec/src/types/Identity.res.mjs";
+import * as AdminApi$ReventlessCore from "@reventlessdev/reventless-core/src/admin/AdminApi.res.mjs";
+import * as DynamoDb_Error$ReventlessAws from "../../errors/DynamoDb_Error.res.mjs";
+import * as PluginBaseFragment$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/api/PluginBaseFragment.res.mjs";
+import * as MCP_SchemaGenerator$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/MCP_SchemaGenerator.res.mjs";
+import * as Util_DynamoDb_Runtime$ReventlessAws from "../../util/Util_DynamoDb_Runtime.res.mjs";
+import * as DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws from "../DcbEventLog/DcbEventLogStorage_DynamoDb_Runtime.res.mjs";
+import * as RequestContextResMjs from "@reventlessdev/reventless-core/src/RequestContext.res.mjs";
+import * as CommandTopicChannel_SQS_RuntimeResMjs from "@reventlessdev/reventless-aws/src/adapter/CommandTopic/CommandTopicChannel_SQS_Runtime.res.mjs";
+import * as CommandGenerator_CallbackResMjs from "@reventlessdev/reventless-core/src/components/CommandGenerator/CommandGenerator_Callback.res.mjs";
+
+function generateConfig(serverName, serverVersion, pluginName, mutationEntries, queryEntries, eventLogEntriesOpt, commandTopicArns, queryDbTableNames, eventLogTableNamesOpt) {
+  let eventLogEntries = eventLogEntriesOpt !== undefined ? eventLogEntriesOpt : [];
+  let eventLogTableNames = eventLogTableNamesOpt !== undefined ? eventLogTableNamesOpt : ({});
+  let toolDefs = MCP_SchemaGenerator$ReventlessCore.generateTools(pluginName, mutationEntries);
+  let kindByField = {};
+  mutationEntries.forEach(entry => {
+    let match = entry.commandSchema;
+    let kind;
+    kind = match.type === "union" ? "Aggregate" : "StateChangeSlice";
+    entry.fieldNames.forEach(fieldName => {
+      kindByField[fieldName] = kind;
+    });
+  });
+  let tools = toolDefs.map(def => ({
+    name: def.name,
+    description: def.description,
+    inputSchema: def.inputSchema,
+    commandTopicArn: Stdlib_Option.getOr(commandTopicArns[def.name], ""),
+    componentKind: Stdlib_Option.getOr(kindByField[def.name], "Aggregate")
+  }));
+  let resourceDefs = MCP_SchemaGenerator$ReventlessCore.generateResources(pluginName, queryEntries);
+  let resources = resourceDefs.map(def => ({
+    name: def.name,
+    description: def.description,
+    uriTemplate: def.uriTemplate,
+    queryDbTableName: Stdlib_Option.getOr(queryDbTableNames[def.name], "")
+  }));
+  let eventHistoryResources = eventLogEntries.map(entry => {
+    let nameLower = entry.displayName.toLowerCase();
+    return {
+      name: nameLower + `_events`,
+      displayName: entry.displayName,
+      tableName: Stdlib_Option.getOr(eventLogTableNames[entry.busKey], ""),
+      busKey: entry.busKey
+    };
+  });
+  return {
+    serverName: serverName,
+    serverVersion: serverVersion,
+    tools: tools,
+    resources: resources,
+    eventHistoryResources: eventHistoryResources
+  };
+}
+
+function generateAdminConfig(serverName, serverVersion, clonerOpt, commandTopicArnsOpt, queryDbTableNamesOpt) {
+  let cloner = clonerOpt !== undefined ? clonerOpt : false;
+  let commandTopicArns = commandTopicArnsOpt !== undefined ? commandTopicArnsOpt : ({});
+  let queryDbTableNames = queryDbTableNamesOpt !== undefined ? queryDbTableNamesOpt : ({});
+  return generateConfig(serverName + `-admin`, serverVersion, "Admin", AdminApi$ReventlessCore.mutationEntries(cloner), PluginBaseFragment$ReventlessCore.queryEntries, undefined, commandTopicArns, queryDbTableNames, undefined);
+}
+
+function extractEntityId(uri) {
+  let pathPart = uri.split("?")[0];
+  let segments = pathPart.split("/");
+  return Stdlib_Option.getOr(segments.at(-1), "");
+}
+
+function parsePaginationParams(uri) {
+  let parts = uri.split("?");
+  let qs = parts[1];
+  if (qs === undefined) {
+    return [
+      undefined,
+      undefined
+    ];
+  }
+  let params = {};
+  qs.split("&").forEach(param => {
+    let kv = param.split("=");
+    let match = kv[0];
+    let match$1 = kv[1];
+    if (match !== undefined && match$1 !== undefined) {
+      params[match] = match$1;
+      return;
+    }
+  });
+  return [
+    Stdlib_Option.flatMap(params["limit"], v => Stdlib_Int.fromString(v, undefined)),
+    params["after"]
+  ];
+}
+
+function paginatedResponse(events, hasMore, nextAfter) {
+  return Object.fromEntries([
+    [
+      "events",
+      events
+    ],
+    [
+      "pagination",
+      Object.fromEntries([
+        [
+          "hasMore",
+          hasMore
+        ],
+        [
+          "nextAfter",
+          Stdlib_Option.mapOr(nextAfter, null, prim => prim)
+        ]
+      ])
+    ]
+  ]);
+}
+
+async function readEventLogHistory(tableName, entityId, limit, after) {
+  let expressionAttributeValues = Object.fromEntries([[
+      ":id",
+      entityId
+    ]]);
+  let exclusiveStartKey = Stdlib_Option.map(after, afterPos => Object.fromEntries([
+    [
+      "id",
+      entityId
+    ],
+    [
+      "position",
+      afterPos
+    ]
+  ]));
+  let stream = Stream$1.catchAll(Util_DynamoDb_Runtime$ReventlessAws.queryStream({
+    TableName: tableName,
+    ConsistentRead: true,
+    ExclusiveStartKey: exclusiveStartKey,
+    ExpressionAttributeValues: expressionAttributeValues,
+    KeyConditionExpression: "id=:id"
+  }), err => {
+    DynamoDb_Error$ReventlessAws.message(err);
+    return Stream$1.empty;
+  });
+  let bounded = limit !== undefined ? Stream$1.take(stream, limit + 1 | 0) : stream;
+  let events = await Effect.runPromise(Stream.runCollect(bounded));
+  let match = limit !== undefined && events.length > limit ? [
+      events.slice(0, limit),
+      true
+    ] : [
+      events,
+      false
+    ];
+  let hasMore = match[1];
+  let limited = match[0];
+  let nextAfter = hasMore ? Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(limited.at(-1), Stdlib_JSON.Decode.object), obj => obj["position"]), Stdlib_JSON.Decode.string) : undefined;
+  return paginatedResponse(limited, hasMore, nextAfter);
+}
+
+async function readDcbEventLogHistory(tableName, entityId, limit, after) {
+  let table = {
+    id: "",
+    name: tableName,
+    arn: "",
+    hashKey: "id"
+  };
+  let result = await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.read(table, undefined)([], after);
+  let filtered = entityId.length > 0 ? result.events.filter(e => e.tags.some(tag => tag.value === entityId)) : result.events;
+  let match = limit !== undefined && filtered.length > limit ? [
+      filtered.slice(0, limit),
+      true
+    ] : [
+      filtered,
+      false
+    ];
+  let hasMore = match[1];
+  let limited = match[0];
+  let eventsJson = limited.map(e => Object.fromEntries([
+    [
+      "position",
+      e.position
+    ],
+    [
+      "event",
+      e.eventType
+    ],
+    [
+      "data",
+      e.data
+    ],
+    [
+      "tags",
+      e.tags.map(t => Object.fromEntries([
+        [
+          "key",
+          t.key
+        ],
+        [
+          "value",
+          t.value
+        ]
+      ]))
+    ]
+  ]));
+  let nextAfter = hasMore ? Stdlib_Option.map(limited.at(-1), e => e.position) : undefined;
+  return paginatedResponse(eventsJson, hasMore, nextAfter);
+}
+
+let makeQueueRef = ((url) => ({ id: url, name: url, arn: "" }));
+
+let decodeJwtClaims = (function(token) {
+    try {
+      var parts = token.split(".");
+      if (parts.length < 2) return undefined;
+      var base64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+      var json = Buffer.from(base64, "base64").toString("utf8");
+      return JSON.parse(json);
+    } catch(_) { return undefined; }
+  });
+
+function extractIdentity(authHeader) {
+  if (authHeader === undefined) {
+    return Identity$Reventless.anonymous;
+  }
+  let token = authHeader.startsWith("Bearer ") ? authHeader.slice(7) : authHeader;
+  let claims = decodeJwtClaims(token);
+  if (claims === undefined) {
+    return Identity$Reventless.anonymous;
+  }
+  let claims$1 = Primitive_option.valFromOption(claims);
+  let userId = Stdlib_Option.getOr(Stdlib_Option.flatMap(claims$1["sub"], Stdlib_JSON.Decode.string), "anonymous");
+  let username = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.orElse(claims$1["cognito:username"], claims$1["username"]), Stdlib_JSON.Decode.string), userId);
+  let groups = Stdlib_Option.getOr(Stdlib_Option.map(claims$1["cognito:groups"], g => g), []);
+  return {
+    userId: userId,
+    username: username,
+    groups: groups,
+    provider: "Cognito"
+  };
+}
+
+function runEffect(correlationId, effect) {
+  return effect.pipe(Effect.provideService(RequestContextResMjs.tag, {
+    correlationId: Stdlib_Option.getOr(correlationId, "unknown")
+  })).pipe(prim => Effect.runPromise(prim));
+}
+
+async function dispatchTool(tool, args, identity) {
+  let queueRef = makeQueueRef(tool.commandTopicArn);
+  let publishJsons = CommandTopicChannel_SQS_RuntimeResMjs.publishJsons(queueRef, AWS$ReventlessAws.SQS_FIFO.service);
+  let generateCommand = CommandGenerator_CallbackResMjs.makeGenerateCommand(publishJsons, tool.name, S.json, tool.componentKind, false);
+  let payload_command = tool.name;
+  let payload_meta = {
+    ip: [],
+    user: identity.userId,
+    info: `mcp/tools/` + tool.name
+  };
+  let payload = {
+    command: payload_command,
+    arguments: args,
+    meta: payload_meta,
+    identity: identity
+  };
+  return await runEffect(undefined, generateCommand(payload));
+}
+
+export {
+  generateConfig,
+  generateAdminConfig,
+  extractEntityId,
+  parsePaginationParams,
+  paginatedResponse,
+  readEventLogHistory,
+  readDcbEventLogHistory,
+  makeQueueRef,
+  decodeJwtClaims,
+  extractIdentity,
+  runEffect,
+  dispatchTool,
+}
+/* S Not a pure module */

package/src/adapter/QueryDb/NodeResolver_AppSync.res

@@ -0,0 +1,71 @@
+// AppSync Relay Node resolver.
+// Creates a pipeline resolver for node(id: ID!) that decodes the global ID
+// and routes to the correct DynamoDB table based on entity type.
+//
+// Usage: call `make` at platform deploy time after all QueryDb components are built,
+// passing the collected (typeName, dataSourceName) pairs.
+
+open PulumiAws.AppSync
+
+type nodeTypeEntry = {
+  typeName: string,
+  dataSourceName: Pulumi.Input.t<string>,
+}
+
+// Tracks registered entity types for the node resolver pipeline.
+let nodeTypeEntries: ref<array<nodeTypeEntry>> = ref([])
+
+let registerNodeType = (~typeName: string, ~dataSourceName: Pulumi.Input.t<string>) =>
+  nodeTypeEntries.contents->Array.push({typeName, dataSourceName})
+
+let make = (
+  ~api: Types.AppSync.api,
+  ~opts: Pulumi.ComponentResource.options,
+) => {
+  let entries = nodeTypeEntries.contents
+  if entries->Array.length == 0 {
+    []
+  } else {
+    let noneDataSource = DataSource.makeNoneDataSource(
+      ~name="NodeResolverNone",
+      ~api,
+      ~opts=ReventlessCore.Util.Pulumi.ComponentResourceOptions.toCustomResourceOptions(opts),
+    )
+
+    // First pipeline function: decode global ID (NONE datasource)
+    let decodeFn = Function.makeJs(
+      ~name="NodeDecodeGlobalId",
+      ~api,
+      ~dataSource=noneDataSource.name->Pulumi.Output.asInput,
+      ~code=Resolver.Functions.nodeDecodeGlobalId,
+      ~opts=ReventlessCore.Util.Pulumi.ComponentResourceOptions.toCustomResourceOptions(opts),
+    )
+
+    // Per-type pipeline functions: each checks ctx.stash.typeName and fetches if matching
+    let typeFunctions = entries->Array.map(entry => {
+      Function.makeJs(
+        ~name="NodeGet" ++ entry.typeName,
+        ~api,
+        ~dataSource=entry.dataSourceName,
+        ~code=Resolver.Functions.nodeGetItemForType(~typeName=entry.typeName),
+        ~opts=ReventlessCore.Util.Pulumi.ComponentResourceOptions.toCustomResourceOptions(opts),
+      )
+    })
+
+    let allFunctions = Array.concat([decodeFn], typeFunctions)
+
+    let resolver = Resolver.makePipelineJsResolver(
+      ~name="NodeResolver",
+      ~api,
+      ~type_="Query"->Pulumi.Input.make,
+      ~field="node"->Pulumi.Input.make,
+      ~code=Resolver.Functions.pipelinePassThrough,
+      ~functions=allFunctions,
+      ~opts=ReventlessCore.Util.Pulumi.ComponentResourceOptions.toCustomResourceOptions(opts),
+    )
+
+    [resolver]->Array.map(Util_AppSync.toResource)
+  }
+}
+
+let reset = () => nodeTypeEntries.contents = []

package/src/adapter/QueryDb/NodeResolver_AppSync.res.mjs

@@ -0,0 +1,44 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as AppSync_Function$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/AppSync/AppSync_Function.res.mjs";
+import * as AppSync_Resolver$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/AppSync/AppSync_Resolver.res.mjs";
+import * as Util_AppSync$ReventlessAws from "../../util/Util_AppSync.res.mjs";
+import * as Util_Pulumi$ReventlessCore from "@reventlessdev/reventless-core/src/util/Util_Pulumi.res.mjs";
+import * as AppSync_DataSource$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/AppSync/AppSync_DataSource.res.mjs";
+import * as AppSync_Resolver_Functions$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/AppSync/AppSync_Resolver_Functions.res.mjs";
+
+let nodeTypeEntries = {
+  contents: []
+};
+
+function registerNodeType(typeName, dataSourceName) {
+  nodeTypeEntries.contents.push({
+    typeName: typeName,
+    dataSourceName: dataSourceName
+  });
+}
+
+function make(api, opts) {
+  let entries = nodeTypeEntries.contents;
+  if (entries.length === 0) {
+    return [];
+  }
+  let noneDataSource = AppSync_DataSource$PulumiAws.makeNoneDataSource("NodeResolverNone", api, Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions(opts));
+  let decodeFn = AppSync_Function$PulumiAws.makeJs("NodeDecodeGlobalId", api, noneDataSource.name, AppSync_Resolver_Functions$PulumiAws.nodeDecodeGlobalId, Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions(opts));
+  let typeFunctions = entries.map(entry => AppSync_Function$PulumiAws.makeJs("NodeGet" + entry.typeName, api, entry.dataSourceName, AppSync_Resolver_Functions$PulumiAws.nodeGetItemForType(entry.typeName), Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions(opts)));
+  let allFunctions = [decodeFn].concat(typeFunctions);
+  let resolver = AppSync_Resolver$PulumiAws.makePipelineJsResolver("NodeResolver", api, "Query", "node", AppSync_Resolver_Functions$PulumiAws.pipelinePassThrough, allFunctions, Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions(opts));
+  return [resolver].map(Util_AppSync$ReventlessAws.toResource);
+}
+
+function reset() {
+  nodeTypeEntries.contents = [];
+}
+
+export {
+  nodeTypeEntries,
+  registerNodeType,
+  make,
+  reset,
+}
+/* AppSync_Function-PulumiAws Not a pure module */

package/src/adapter/QueryDb/QueryDbResolvers.res

@@ -0,0 +1,2 @@
+module AppSync = QueryDbResolvers_AppSync
+module NoOp = QueryDbResolvers_NoOp

package/src/adapter/QueryDb/QueryDbResolvers.res.mjs

@@ -0,0 +1,12 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let AppSync;
+
+let NoOp;
+
+export {
+  AppSync,
+  NoOp,
+}
+/* No side effect */