@teamkeel/functions-runtime 0.424.0 → 0.425.0

package/dist/index.cjs

@@ -608,175 +608,40 @@ __name(getDialect, "getDialect");
 var import_client_s3 = require("@aws-sdk/client-s3");
 var import_credential_providers = require("@aws-sdk/credential-providers");
 var import_s3_request_presigner = require("@aws-sdk/s3-request-presigner");
-
-// src/errors.js
-var import_json_rpc_2 = require("json-rpc-2.0");
-var RuntimeErrors = {
-  // Catchall error type for unhandled execution errors during custom function
-  UnknownError: -32001,
-  // DatabaseError represents any error at pg level that isn't handled explicitly below
-  DatabaseError: -32002,
-  // No result returned from custom function by user
-  NoResultError: -32003,
-  // When trying to delete/update a non existent record in the db
-  RecordNotFoundError: -32004,
-  ForeignKeyConstraintError: -32005,
-  NotNullConstraintError: -32006,
-  UniqueConstraintError: -32007,
-  PermissionError: -32008,
-  BadRequestError: -32009
-};
-var PermissionError = class extends Error {
-  static {
-    __name(this, "PermissionError");
-  }
-};
-var DatabaseError = class extends Error {
-  static {
-    __name(this, "DatabaseError");
-  }
-  constructor(error) {
-    super(error.message);
-    this.error = error;
-  }
-};
-var NotFoundError = class extends Error {
-  static {
-    __name(this, "NotFoundError");
-  }
-  errorCode = RuntimeErrors.RecordNotFoundError;
-  constructor(message) {
-    super(message);
-  }
-};
-var BadRequestError = class extends Error {
-  static {
-    __name(this, "BadRequestError");
-  }
-  errorCode = RuntimeErrors.BadRequestError;
-  constructor(message = "bad request") {
-    super(message);
-  }
-};
-var UnknownError = class extends Error {
-  static {
-    __name(this, "UnknownError");
-  }
-  errorCode = RuntimeErrors.UnknownError;
-  constructor(message = "unknown error") {
-    super(message);
-  }
-};
-var ErrorPresets = {
-  NotFound: NotFoundError,
-  BadRequest: BadRequestError,
-  Unknown: UnknownError
-};
-function errorToJSONRPCResponse(request, e) {
-  switch (e.constructor.name) {
-    case "PermissionError":
-      return (0, import_json_rpc_2.createJSONRPCErrorResponse)(
-        request.id,
-        RuntimeErrors.PermissionError,
-        e.message
-      );
-    // Any error thrown in the ModelAPI class is
-    // wrapped in a DatabaseError in order to differentiate 'our code' vs the user's own code.
-    case "NoResultError":
-      return (0, import_json_rpc_2.createJSONRPCErrorResponse)(
-        request.id,
-        // to be matched to https://github.com/teamkeel/keel/blob/e3115ffe381bfc371d4f45bbf96a15072a994ce5/runtime/actions/update.go#L54-L54
-        RuntimeErrors.RecordNotFoundError,
-        ""
-        // Don't pass on the message as we want to normalise these at the runtime layer but still support custom messages in other NotFound errors
-      );
-    case "DatabaseError":
-      let err = e;
-      if (e instanceof DatabaseError) {
-        err = e.error;
-      }
-      if (err.constructor.name == "NoResultError") {
-        return (0, import_json_rpc_2.createJSONRPCErrorResponse)(
-          request.id,
-          // to be matched to https://github.com/teamkeel/keel/blob/e3115ffe381bfc371d4f45bbf96a15072a994ce5/runtime/actions/update.go#L54-L54
-          RuntimeErrors.RecordNotFoundError,
-          ""
-          // Don't pass on the message as we want to normalise these at the runtime layer but still support custom messages in other NotFound errors
-        );
-      }
-      if ("code" in err) {
-        const { code: code2, detail, table: table2 } = err;
-        let rpcErrorCode, column, value;
-        const [col, val] = parseKeyMessage(err.detail);
-        column = col;
-        value = val;
-        switch (code2) {
-          case "23502":
-            rpcErrorCode = RuntimeErrors.NotNullConstraintError;
-            column = err.column;
-            break;
-          case "23503":
-            rpcErrorCode = RuntimeErrors.ForeignKeyConstraintError;
-            break;
-          case "23505":
-            rpcErrorCode = RuntimeErrors.UniqueConstraintError;
-            break;
-          default:
-            rpcErrorCode = RuntimeErrors.DatabaseError;
-            break;
-        }
-        return (0, import_json_rpc_2.createJSONRPCErrorResponse)(request.id, rpcErrorCode, e.message, {
-          table: table2,
-          column,
-          code: code2,
-          detail,
-          value
-        });
-      }
-      return (0, import_json_rpc_2.createJSONRPCErrorResponse)(
-        request.id,
-        RuntimeErrors.DatabaseError,
-        e.message
-      );
-    default:
-      return (0, import_json_rpc_2.createJSONRPCErrorResponse)(
-        request.id,
-        e.errorCode ?? RuntimeErrors.UnknownError,
-        e.message
-      );
-  }
-}
-__name(errorToJSONRPCResponse, "errorToJSONRPCResponse");
-var keyMessagePattern = /\Key\s[(](.*)[)][=][(](.*)[)]/;
-var parseKeyMessage = /* @__PURE__ */ __name((msg) => {
-  const [, col, value] = keyMessagePattern.exec(msg) || [];
-  return [col, value];
-}, "parseKeyMessage");
-
-// src/File.ts
 var import_ksuid = __toESM(require("ksuid"), 1);
 var s3Client = (() => {
   if (!process.env.KEEL_FILES_BUCKET_NAME) {
     return null;
   }
-  const endpoint = process.env.TEST_AWS_ENDPOINT;
-  if (!endpoint) {
+  const endpoint = process.env.KEEL_S3_ENDPOINT;
+  if (endpoint) {
+    return new import_client_s3.S3Client({
+      region: process.env.KEEL_REGION,
+      credentials: {
+        accessKeyId: "keelstorage",
+        secretAccessKey: "keelstorage"
+      },
+      endpoint
+    });
+  }
+  const testEndpoint = process.env.TEST_AWS_ENDPOINT;
+  if (testEndpoint) {
     return new import_client_s3.S3Client({
       region: process.env.KEEL_REGION,
-      credentials: (0, import_credential_providers.fromEnv)()
+      credentials: {
+        accessKeyId: "test",
+        secretAccessKey: "test"
+      },
+      endpointProvider: /* @__PURE__ */ __name(() => {
+        return {
+          url: new URL(testEndpoint)
+        };
+      }, "endpointProvider")
     });
   }
   return new import_client_s3.S3Client({
     region: process.env.KEEL_REGION,
-    credentials: {
-      accessKeyId: "test",
-      secretAccessKey: "test"
-    },
-    endpointProvider: /* @__PURE__ */ __name(() => {
-      return {
-        url: new URL(endpoint)
-      };
-    }, "endpointProvider")
+    credentials: (0, import_credential_providers.fromEnv)()
   });
 })();
 var InlineFile = class _InlineFile {
@@ -881,24 +746,17 @@ var File = class _File extends InlineFile {
       const arrayBuffer = await this._contents.arrayBuffer();
       return Buffer.from(arrayBuffer);
     }
-    if (s3Client) {
-      const params = {
-        Bucket: process.env.KEEL_FILES_BUCKET_NAME,
-        Key: "files/" + this.key
-      };
-      const command = new import_client_s3.GetObjectCommand(params);
-      const response = await s3Client.send(command);
-      const blob = await response.Body.transformToByteArray();
-      return Buffer.from(blob);
-    }
-    const db = useDatabase();
-    try {
-      const query = db.selectFrom("keel_storage").select("data").where("id", "=", this.key);
-      const row = await query.executeTakeFirstOrThrow();
-      return row.data;
-    } catch (e) {
-      throw new DatabaseError(e);
+    if (!s3Client) {
+      throw new Error("S3 client is required");
     }
+    const params = {
+      Bucket: process.env.KEEL_FILES_BUCKET_NAME,
+      Key: "files/" + this.key
+    };
+    const command = new import_client_s3.GetObjectCommand(params);
+    const response = await s3Client.send(command);
+    const blob = await response.Body.transformToByteArray();
+    return Buffer.from(blob);
   }
   async store(expires = null) {
     if (this._contents) {
@@ -916,17 +774,16 @@ var File = class _File extends InlineFile {
   }
   // Generates a presigned download URL
   async getPresignedUrl() {
-    if (s3Client) {
-      const command = new import_client_s3.GetObjectCommand({
-        Bucket: process.env.KEEL_FILES_BUCKET_NAME,
-        Key: "files/" + this.key,
-        ResponseContentDisposition: "inline"
-      });
-      const url = await (0, import_s3_request_presigner.getSignedUrl)(s3Client, command, { expiresIn: 60 * 60 });
-      return new URL(url);
-    } else {
-      return new URL(`${process.env.KEEL_API_URL}/files/${this.key}`);
+    if (!s3Client) {
+      throw new Error("S3 client is required");
     }
+    const command = new import_client_s3.GetObjectCommand({
+      Bucket: process.env.KEEL_FILES_BUCKET_NAME,
+      Key: "files/" + this.key,
+      ResponseContentDisposition: "inline"
+    });
+    const url = await (0, import_s3_request_presigner.getSignedUrl)(s3Client, command, { expiresIn: 60 * 60 });
+    return new URL(url);
   }
   // Persists the file
   toDbRecord() {
@@ -942,54 +799,36 @@ var File = class _File extends InlineFile {
   }
 };
 async function storeFile(contents, key, filename, contentType, size, expires) {
-  if (s3Client) {
-    const params = {
-      Bucket: process.env.KEEL_FILES_BUCKET_NAME,
-      Key: "files/" + key,
-      Body: contents,
-      ContentType: contentType,
-      ContentDisposition: `attachment; filename="${encodeURIComponent(
-        filename
-      )}"`,
-      Metadata: {
-        filename
-      },
-      ACL: "private"
-    };
-    if (expires) {
-      if (expires instanceof Date) {
-        params.Expires = expires;
-      } else {
-        console.warn("Invalid expires value. Skipping Expires parameter.");
-      }
-    }
-    const command = new import_client_s3.PutObjectCommand(params);
-    try {
-      await s3Client.send(command);
-    } catch (error) {
-      console.error("Error uploading file:", error);
-      throw error;
-    }
-  } else {
-    const db = useDatabase();
-    try {
-      const query = db.insertInto("keel_storage").values({
-        id: key,
-        filename,
-        content_type: contentType,
-        data: contents
-      }).onConflict(
-        (oc) => oc.column("id").doUpdateSet(() => ({
-          filename,
-          content_type: contentType,
-          data: contents
-        })).where("keel_storage.id", "=", key)
-      ).returningAll();
-      await query.execute();
-    } catch (e) {
-      throw new DatabaseError(e);
+  if (!s3Client) {
+    throw new Error("S3 client is required");
+  }
+  const params = {
+    Bucket: process.env.KEEL_FILES_BUCKET_NAME,
+    Key: "files/" + key,
+    Body: contents,
+    ContentType: contentType,
+    ContentDisposition: `attachment; filename="${encodeURIComponent(
+      filename
+    )}"`,
+    Metadata: {
+      filename
+    },
+    ACL: "private"
+  };
+  if (expires) {
+    if (expires instanceof Date) {
+      params.Expires = expires;
+    } else {
+      console.warn("Invalid expires value. Skipping Expires parameter.");
     }
   }
+  const command = new import_client_s3.PutObjectCommand(params);
+  try {
+    await s3Client.send(command);
+  } catch (error) {
+    console.error("Error uploading file:", error);
+    throw error;
+  }
 }
 __name(storeFile, "storeFile");
 
@@ -1429,6 +1268,150 @@ function joinAlias(tablePath) {
 }
 __name(joinAlias, "joinAlias");
 
+// src/errors.js
+var import_json_rpc_2 = require("json-rpc-2.0");
+var RuntimeErrors = {
+  // Catchall error type for unhandled execution errors during custom function
+  UnknownError: -32001,
+  // DatabaseError represents any error at pg level that isn't handled explicitly below
+  DatabaseError: -32002,
+  // No result returned from custom function by user
+  NoResultError: -32003,
+  // When trying to delete/update a non existent record in the db
+  RecordNotFoundError: -32004,
+  ForeignKeyConstraintError: -32005,
+  NotNullConstraintError: -32006,
+  UniqueConstraintError: -32007,
+  PermissionError: -32008,
+  BadRequestError: -32009
+};
+var PermissionError = class extends Error {
+  static {
+    __name(this, "PermissionError");
+  }
+};
+var DatabaseError = class extends Error {
+  static {
+    __name(this, "DatabaseError");
+  }
+  constructor(error) {
+    super(error.message);
+    this.error = error;
+  }
+};
+var NotFoundError = class extends Error {
+  static {
+    __name(this, "NotFoundError");
+  }
+  errorCode = RuntimeErrors.RecordNotFoundError;
+  constructor(message) {
+    super(message);
+  }
+};
+var BadRequestError = class extends Error {
+  static {
+    __name(this, "BadRequestError");
+  }
+  errorCode = RuntimeErrors.BadRequestError;
+  constructor(message = "bad request") {
+    super(message);
+  }
+};
+var UnknownError = class extends Error {
+  static {
+    __name(this, "UnknownError");
+  }
+  errorCode = RuntimeErrors.UnknownError;
+  constructor(message = "unknown error") {
+    super(message);
+  }
+};
+var ErrorPresets = {
+  NotFound: NotFoundError,
+  BadRequest: BadRequestError,
+  Unknown: UnknownError
+};
+function errorToJSONRPCResponse(request, e) {
+  switch (e.constructor.name) {
+    case "PermissionError":
+      return (0, import_json_rpc_2.createJSONRPCErrorResponse)(
+        request.id,
+        RuntimeErrors.PermissionError,
+        e.message
+      );
+    // Any error thrown in the ModelAPI class is
+    // wrapped in a DatabaseError in order to differentiate 'our code' vs the user's own code.
+    case "NoResultError":
+      return (0, import_json_rpc_2.createJSONRPCErrorResponse)(
+        request.id,
+        // to be matched to https://github.com/teamkeel/keel/blob/e3115ffe381bfc371d4f45bbf96a15072a994ce5/runtime/actions/update.go#L54-L54
+        RuntimeErrors.RecordNotFoundError,
+        ""
+        // Don't pass on the message as we want to normalise these at the runtime layer but still support custom messages in other NotFound errors
+      );
+    case "DatabaseError":
+      let err = e;
+      if (e instanceof DatabaseError) {
+        err = e.error;
+      }
+      if (err.constructor.name == "NoResultError") {
+        return (0, import_json_rpc_2.createJSONRPCErrorResponse)(
+          request.id,
+          // to be matched to https://github.com/teamkeel/keel/blob/e3115ffe381bfc371d4f45bbf96a15072a994ce5/runtime/actions/update.go#L54-L54
+          RuntimeErrors.RecordNotFoundError,
+          ""
+          // Don't pass on the message as we want to normalise these at the runtime layer but still support custom messages in other NotFound errors
+        );
+      }
+      if ("code" in err) {
+        const { code: code2, detail, table: table2 } = err;
+        let rpcErrorCode, column, value;
+        const [col, val] = parseKeyMessage(err.detail);
+        column = col;
+        value = val;
+        switch (code2) {
+          case "23502":
+            rpcErrorCode = RuntimeErrors.NotNullConstraintError;
+            column = err.column;
+            break;
+          case "23503":
+            rpcErrorCode = RuntimeErrors.ForeignKeyConstraintError;
+            break;
+          case "23505":
+            rpcErrorCode = RuntimeErrors.UniqueConstraintError;
+            break;
+          default:
+            rpcErrorCode = RuntimeErrors.DatabaseError;
+            break;
+        }
+        return (0, import_json_rpc_2.createJSONRPCErrorResponse)(request.id, rpcErrorCode, e.message, {
+          table: table2,
+          column,
+          code: code2,
+          detail,
+          value
+        });
+      }
+      return (0, import_json_rpc_2.createJSONRPCErrorResponse)(
+        request.id,
+        RuntimeErrors.DatabaseError,
+        e.message
+      );
+    default:
+      return (0, import_json_rpc_2.createJSONRPCErrorResponse)(
+        request.id,
+        e.errorCode ?? RuntimeErrors.UnknownError,
+        e.message
+      );
+  }
+}
+__name(errorToJSONRPCResponse, "errorToJSONRPCResponse");
+var keyMessagePattern = /\Key\s[(](.*)[)][=][(](.*)[)]/;
+var parseKeyMessage = /* @__PURE__ */ __name((msg) => {
+  const [, col, value] = keyMessagePattern.exec(msg) || [];
+  return [col, value];
+}, "parseKeyMessage");
+
 // src/QueryBuilder.js
 var QueryBuilder = class _QueryBuilder {
   static {
@@ -2501,15 +2484,38 @@ async function page(options, data, action) {
   const content = options.content;
   let hasValidationErrors = false;
   let validationError;
-  if (options.actions && action !== null) {
-    const isValidAction = options.actions.some((a) => {
-      if (typeof a === "string") return a === action;
-      return a && typeof a === "object" && "value" in a && a.value === action;
-    });
-    if (!isValidAction) {
-      hasValidationErrors = true;
-      validationError = "invalid action";
+  if (options.actions && options.actions.length > 0) {
+    const normalizedAction = action === "undefined" || action === void 0 ? null : action;
+    if (data !== null) {
+      if (normalizedAction === null) {
+        const validValues = options.actions.map((a) => {
+          if (typeof a === "string") return a;
+          return a && typeof a === "object" && "value" in a ? a.value : "";
+        }).filter(Boolean);
+        throw new Error(
+          `action is required. Valid actions are: ${validValues.join(", ")}`
+        );
+      }
+      const isValidAction = options.actions.some((a) => {
+        if (typeof a === "string") return a === normalizedAction;
+        return a && typeof a === "object" && "value" in a && a.value === normalizedAction;
+      });
+      if (!isValidAction) {
+        const validValues = options.actions.map((a) => {
+          if (typeof a === "string") return a;
+          return a && typeof a === "object" && "value" in a ? a.value : "";
+        }).filter(Boolean);
+        throw new Error(
+          `invalid action "${normalizedAction}". Valid actions are: ${validValues.join(
+            ", "
+          )}`
+        );
+      }
     }
+  } else if (action !== null && action !== void 0 && action !== "undefined") {
+    throw new Error(
+      `invalid action "${action}". No actions are defined for this page`
+    );
   }
   const contentUiConfig = await Promise.all(
     content.map(async (c) => {