@teamkeel/functions-runtime 0.411.0-next.2 → 0.411.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamkeel/functions-runtime",
-  "version": "0.411.0-next.2",
+  "version": "0.411.0",
   "description": "Internal package used by @teamkeel/sdk",
   "main": "src/index.js",
   "scripts": {

package/src/camelCasePlugin.js

@@ -25,6 +25,10 @@ class KeelCamelCasePlugin {
   }
   mapRow(row) {
     return Object.keys(row).reduce((obj, key) => {
+      // Fields using @sequence will have a corresponding __sequence field which we drop as we don't want to return it
+      if (key.endsWith("__sequence")) {
+        return obj;
+      }
       let value = row[key];
       if (Array.isArray(value)) {
         value = value.map((it) =>

package/src/consts.js

@@ -9,7 +9,6 @@ const PROTO_ACTION_TYPES = {
   WRITE: "ACTION_TYPE_WRITE",
   JOB: "JOB_TYPE",
   SUBSCRIBER: "SUBSCRIBER_TYPE",
-  FLOW: "FLOW_TYPE",
 };
 
 module.exports.PROTO_ACTION_TYPES = PROTO_ACTION_TYPES;

package/src/index.js

@@ -4,7 +4,6 @@ const { handleRequest } = require("./handleRequest");
 const { handleJob } = require("./handleJob");
 const { handleSubscriber } = require("./handleSubscriber");
 const { handleRoute } = require("./handleRoute");
-const { handleFlow } = require("./handleFlow");
 const KSUID = require("ksuid");
 const { useDatabase } = require("./database");
 const {
@@ -16,7 +15,6 @@ const tracing = require("./tracing");
 const { InlineFile, File } = require("./File");
 const { Duration } = require("./Duration");
 const { ErrorPresets } = require("./errors");
-const { StepRunner } = require("./StepRunner");
 
 module.exports = {
   ModelAPI,
@@ -25,18 +23,15 @@ module.exports = {
   handleJob,
   handleSubscriber,
   handleRoute,
-  handleFlow,
-  KSUID,
   useDatabase,
+  Duration,
+  InlineFile,
+  File,
   Permissions,
   PERMISSION_STATE,
   checkBuiltInPermissions,
   tracing,
-  InlineFile,
-  File,
-  Duration,
   ErrorPresets,
-  StepRunner,
   ksuid() {
     return KSUID.randomSync().string;
   },

package/src/StepRunner.js

@@ -1,97 +0,0 @@
-const { useDatabase } = require("./database");
-
-const STEP_STATUS = {
-  NEW: "NEW",
-  COMPLETED: "COMPLETED",
-  FAILED: "FAILED",
-};
-
-const STEP_TYPE = {
-  FUNCTION: "FUNCTION",
-  IO: "IO",
-  DELAY: "DELAY",
-};
-
-const defaultOpts = {
-  maxRetries: 5,
-  timeoutInMs: 60000,
-};
-
-// This is a special type that is thrown to disrupt the execution of a flow
-class FlowDisrupt {
-  constructor() {}
-}
-
-class StepRunner {
-  constructor(runId) {
-    this.runId = runId;
-  }
-
-  async run(name, fn, opts) {
-    const db = useDatabase();
-
-    // First check if we already have a result for this step
-    const completed = await db
-      .selectFrom("keel_flow_step")
-      .where("run_id", "=", this.runId)
-      .where("name", "=", name)
-      .where("status", "=", STEP_STATUS.COMPLETED)
-      .selectAll()
-      .executeTakeFirst();
-
-    if (completed) {
-      return completed.value;
-    }
-
-    // The step hasn't yet run successfully, so we need to create a NEW run
-    const step = await db
-      .insertInto("keel_flow_step")
-      .values({
-        run_id: this.runId,
-        name: name,
-        status: STEP_STATUS.NEW,
-        type: STEP_TYPE.FUNCTION,
-        maxRetries: opts?.maxRetries ?? defaultOpts.maxRetries,
-        timeoutInMs: opts?.timeoutInMs ?? defaultOpts.timeoutInMs,
-      })
-      .returningAll()
-      .executeTakeFirst();
-
-    let outcome = STEP_STATUS.COMPLETED;
-
-    let result = null;
-    try {
-      result = await withTimeout(fn(), step.timeoutInMs);
-    } catch (e) {
-      outcome = STEP_STATUS.FAILED;
-    }
-
-    // Very crudely store the result in the database
-    await db
-      .updateTable("keel_flow_step")
-      .set({
-        status: outcome,
-        value: JSON.stringify(result),
-      })
-      .where("id", "=", step.id)
-      .returningAll()
-      .executeTakeFirst();
-
-    throw new FlowDisrupt();
-  }
-}
-
-function wait(milliseconds) {
-  return new Promise((resolve) => setTimeout(resolve, milliseconds));
-}
-
-function withTimeout(promiseFn, timeout) {
-  return Promise.race([
-    promiseFn,
-    wait(timeout).then(() => {
-      throw new Error(`flow times out after ${timeout}ms`);
-    }),
-  ]);
-}
-
-module.exports = { StepRunner, FlowDisrupt, withTimeout };

package/src/handleFlow.js

@@ -1,126 +0,0 @@
-const {
-  createJSONRPCErrorResponse,
-  createJSONRPCSuccessResponse,
-  JSONRPCErrorCode,
-} = require("json-rpc-2.0");
-const { createDatabaseClient } = require("./database");
-const { errorToJSONRPCResponse, RuntimeErrors } = require("./errors");
-const opentelemetry = require("@opentelemetry/api");
-const { withSpan } = require("./tracing");
-const { tryExecuteFlow } = require("./tryExecuteFlow");
-const { parseInputs } = require("./parsing");
-const { FlowDisrupt } = require("./StepRunner");
-
-async function handleFlow(request, config) {
-  // Try to extract trace context from caller
-  const activeContext = opentelemetry.propagation.extract(
-    opentelemetry.context.active(),
-    request.meta?.tracing
-  );
-
-  // Run the whole request with the extracted context
-  return opentelemetry.context.with(activeContext, () => {
-    // Wrapping span for the whole request
-    return withSpan(request.method, async (span) => {
-      let db = null;
-
-      const runId = request.meta?.runId;
-
-      try {
-        if (!runId) {
-          throw new Error("no runId provided");
-        }
-
-        const { createFlowContextAPI, flows } = config;
-
-        if (!(request.method in flows)) {
-          const message = `no corresponding flow found for '${request.method}'`;
-          span.setStatus({
-            code: opentelemetry.SpanStatusCode.ERROR,
-            message: message,
-          });
-          return createJSONRPCErrorResponse(
-            request.id,
-            JSONRPCErrorCode.MethodNotFound,
-            message
-          );
-        }
-
-        // The ctx argument passed into the flow function.
-        const ctx = createFlowContextAPI({
-          meta: request.meta,
-        });
-
-        db = createDatabaseClient({
-          connString: request.meta?.secrets?.KEEL_DB_CONN,
-        });
-
-        const flowRun = await db
-          .selectFrom("keel_flow_run")
-          .where("id", "=", runId)
-          .selectAll()
-          .executeTakeFirst();
-
-        if (!flowRun) {
-          throw new Error("no flow run found");
-        }
-
-        const flowFunction = flows[request.method];
-
-        await tryExecuteFlow(db, async () => {
-          // parse request params to convert objects into rich field types (e.g. InlineFile)
-          const inputs = parseInputs(flowRun.input);
-
-          return flowFunction(ctx, inputs);
-        });
-
-        // If we reach this point, then we know the entire flow completed successfully
-        // TODO: Send FlowRunUpdated event with run_completed = true
-        return createJSONRPCSuccessResponse(request.id, {
-          runId: runId,
-          runCompleted: true,
-        });
-      } catch (e) {
-        // If the flow is disrupted, then we know that a step either completed successfully or failed
-        if (e instanceof FlowDisrupt) {
-          // TODO: Send FlowRunUpdated event with run_completed = false
-          return createJSONRPCSuccessResponse(request.id, {
-            runId: runId,
-            runCompleted: false,
-          });
-        }
-
-        if (e instanceof Error) {
-          span.recordException(e);
-          span.setStatus({
-            code: opentelemetry.SpanStatusCode.ERROR,
-            message: e.message,
-          });
-          return errorToJSONRPCResponse(request, e);
-        }
-
-        const message = JSON.stringify(e);
-
-        span.setStatus({
-          code: opentelemetry.SpanStatusCode.ERROR,
-          message: message,
-        });
-
-        return createJSONRPCErrorResponse(
-          request.id,
-          RuntimeErrors.UnknownError,
-          message
-        );
-      } finally {
-        if (db) {
-          await db.destroy();
-        }
-      }
-    });
-  });
-}
-
-module.exports = {
-  handleFlow,
-  RuntimeErrors,
-};

package/src/routes/customResponse.ts

@@ -1,16 +0,0 @@
-import { RouteFunction } from "@teamkeel/sdk";
-
-const handler: RouteFunction = async (request, ctx) => {
-  return {
-    body: JSON.stringify({
-      message: "This is a raw HTTP response",
-      timestamp: new Date().toISOString(),
-    }),
-    statusCode: 200,
-    headers: {
-      "Content-Type": "application/json",
-    },
-  };
-};
-
-export default handler;

package/src/tryExecuteFlow.js

@@ -1,9 +0,0 @@
-const { withDatabase } = require("./database");
-
-function tryExecuteFlow(db, cb) {
-  return withDatabase(db, false, async () => {
-    return cb();
-  });
-}
-
-module.exports.tryExecuteFlow = tryExecuteFlow;