@teamkeel/functions-runtime 0.412.1 → 0.413.2-next.1

package/src/Duration.test.js

@@ -1,34 +0,0 @@
-import { test, expect } from "vitest";
-const { Duration } = require("./Duration");
-
-test("fromISOString test", async () => {
-  const fullDate = Duration.fromISOString("P1Y2M3DT4H5M6S");
-  expect(fullDate.toISOString()).toEqual("P1Y2M3DT4H5M6S");
-  expect(fullDate.toPostgres()).toEqual(
-    "1 years 2 months 3 days 4 hours 5 minutes 6 seconds"
-  );
-  const dateOnly = Duration.fromISOString("P2Y3M4D");
-  expect(dateOnly.toISOString()).toEqual("P2Y3M4D");
-  expect(dateOnly.toPostgres()).toEqual("2 years 3 months 4 days");
-  const timeOnly = Duration.fromISOString("PT4H5M6S");
-  expect(timeOnly.toISOString()).toEqual("PT4H5M6S");
-  expect(timeOnly.toPostgres()).toEqual("4 hours 5 minutes 6 seconds");
-  const years = Duration.fromISOString("P10Y");
-  expect(years.toISOString()).toEqual("P10Y");
-  expect(years.toPostgres()).toEqual("10 years");
-  const months = Duration.fromISOString("P20M");
-  expect(months.toISOString()).toEqual("P20M");
-  expect(months.toPostgres()).toEqual("20 months");
-  const days = Duration.fromISOString("P31D");
-  expect(days.toISOString()).toEqual("P31D");
-  expect(days.toPostgres()).toEqual("31 days");
-  const hours = Duration.fromISOString("PT4H");
-  expect(hours.toISOString()).toEqual("PT4H");
-  expect(hours.toPostgres()).toEqual("4 hours");
-  const minutes = Duration.fromISOString("PT61M");
-  expect(minutes.toISOString()).toEqual("PT61M");
-  expect(minutes.toPostgres()).toEqual("61 minutes");
-  const seconds = Duration.fromISOString("PT76S");
-  expect(seconds.toISOString()).toEqual("PT76S");
-  expect(seconds.toPostgres()).toEqual("76 seconds");
-});

package/src/File.js

@@ -1,295 +0,0 @@
-const {
-  S3Client,
-  PutObjectCommand,
-  GetObjectCommand,
-} = require("@aws-sdk/client-s3");
-const { fromEnv } = require("@aws-sdk/credential-providers");
-const { getSignedUrl } = require("@aws-sdk/s3-request-presigner");
-const { useDatabase } = require("./database");
-const { DatabaseError } = require("./errors");
-const KSUID = require("ksuid");
-
-const s3Client = (() => {
-  if (!process.env.KEEL_FILES_BUCKET_NAME) {
-    return null;
-  }
-
-  // Set in integration tests to send all AWS API calls to a test server
-  // for mocking
-  const endpoint = process.env.TEST_AWS_ENDPOINT;
-
-  if (!endpoint) {
-    // If no test endpoint is provided then use the env's configuration
-    return new S3Client({
-      region: process.env.KEEL_REGION,
-      credentials: fromEnv(),
-    });
-  }
-
-  return new S3Client({
-    region: process.env.KEEL_REGION,
-
-    // If a test endpoint is provided then use some test credentials
-    credentials: {
-      accessKeyId: "test",
-      secretAccessKey: "test",
-    },
-
-    // If a custom endpoint is set we need to use a custom resolver. Just setting the base endpoint isn't enough for S3 as it
-    // as the default resolver uses the bucket name as a sub-domain, which likely won't work with the custom endpoint.
-    // By implementing a full resolver we can force it to be the endpoint we want.
-    endpointProvider: () => {
-      return {
-        url: new URL(endpoint),
-      };
-    },
-  });
-})();
-
-class InlineFile {
-  constructor({ filename, contentType }) {
-    this._filename = filename;
-    this._contentType = contentType;
-    this._contents = null;
-  }
-
-  static fromDataURL(dataURL) {
-    var info = dataURL.split(",")[0].split(":")[1];
-    var data = dataURL.split(",")[1];
-    var mime = info.split(";")[0];
-    var name = info.split(";")[1].split("=")[1];
-    var buffer = Buffer.from(data, "base64");
-    var file = new InlineFile({ filename: name, contentType: mime });
-    file.write(buffer);
-
-    return file;
-  }
-
-  get size() {
-    if (this._contents) {
-      return this._contents.size;
-    } else {
-      return 0;
-    }
-  }
-
-  get contentType() {
-    return this._contentType;
-  }
-
-  get filename() {
-    return this._filename;
-  }
-
-  write(buffer) {
-    this._contents = new Blob([buffer]);
-  }
-
-  // Read the contents of the file. If URL is set, it will be read from the remote storage, otherwise, if dataURL is set
-  // on the instance, it will return a blob with the file contents
-  async read() {
-    const arrayBuffer = await this._contents.arrayBuffer();
-    const buffer = Buffer.from(arrayBuffer);
-
-    return buffer;
-  }
-
-  async store(expires = null) {
-    const content = await this.read();
-    const key = KSUID.randomSync().string;
-
-    await storeFile(
-      content,
-      key,
-      this._filename,
-      this._contentType,
-      this.size,
-      expires
-    );
-
-    return new File({
-      key: key,
-      size: this.size,
-      filename: this.filename,
-      contentType: this.contentType,
-    });
-  }
-}
-
-class File extends InlineFile {
-  constructor(input) {
-    super({ filename: input.filename, contentType: input.contentType });
-    this._key = input.key;
-    this._size = input.size;
-  }
-
-  static fromDbRecord({ key, filename, size, contentType }) {
-    return new File({
-      key: key,
-      filename: filename,
-      size: size,
-      contentType: contentType,
-    });
-  }
-
-  get size() {
-    return this._size;
-  }
-
-  get key() {
-    return this._key;
-  }
-
-  async read() {
-    if (this._contents) {
-      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 GetObjectCommand(params);
-      const response = await s3Client.send(command);
-      const blob = await response.Body.transformToByteArray();
-      return Buffer.from(blob);
-    }
-
-    // default to db storage
-    const db = useDatabase();
-
-    try {
-      let 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);
-    }
-  }
-
-  async store(expires = null) {
-    // Only necessary to store the file if the contents have been changed
-    if (this._contents) {
-      const contents = await this.read();
-      await storeFile(
-        contents,
-        this.key,
-        this.filename,
-        this.contentType,
-        expires
-      );
-    }
-    return this;
-  }
-
-  async getPresignedUrl() {
-    if (s3Client) {
-      const command = new GetObjectCommand({
-        Bucket: process.env.KEEL_FILES_BUCKET_NAME,
-        Key: "files/" + this.key,
-        ResponseContentDisposition: "inline",
-      });
-
-      const url = await getSignedUrl(s3Client, command, { expiresIn: 60 * 60 });
-
-      return new URL(url);
-    } else {
-      const contents = await this.read();
-      const dataurl = `data:${this.contentType};name=${
-        this.filename
-      };base64,${contents.toString("base64")}`;
-      return new URL(dataurl);
-    }
-  }
-
-  toDbRecord() {
-    return {
-      key: this.key,
-      filename: this.filename,
-      contentType: this.contentType,
-      size: this.size,
-    };
-  }
-
-  toJSON() {
-    return {
-      key: this.key,
-      filename: this.filename,
-      contentType: this.contentType,
-      size: this.size,
-    };
-  }
-}
-
-async function storeFile(contents, key, filename, contentType, 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: filename,
-      },
-      ACL: "private",
-    };
-
-    if (expires) {
-      if (expires instanceof Date) {
-        params.Expires = expires;
-      } else {
-        console.warn("Invalid expires value. Skipping Expires parameter.");
-      }
-    }
-
-    const command = new PutObjectCommand(params);
-    try {
-      await s3Client.send(command);
-    } catch (error) {
-      console.error("Error uploading file:", error);
-      throw error;
-    }
-  } else {
-    const db = useDatabase();
-
-    try {
-      let query = db
-        .insertInto("keel_storage")
-        .values({
-          id: key,
-          filename: filename,
-          content_type: contentType,
-          data: contents,
-        })
-        .onConflict((oc) =>
-          oc
-            .column("id")
-            .doUpdateSet(() => ({
-              filename: filename,
-              content_type: contentType,
-              data: contents,
-            }))
-            .where("keel_storage.id", "=", key)
-        )
-        .returningAll();
-
-      await query.execute();
-    } catch (e) {
-      throw new DatabaseError(e);
-    }
-  }
-}
-
-module.exports = {
-  InlineFile,
-  File,
-};

package/src/ModelAPI.js

@@ -1,377 +0,0 @@
-const { sql } = require("kysely");
-const { useDatabase } = require("./database");
-const {
-  transformRichDataTypes,
-  isReferencingExistingRecord,
-} = require("./parsing");
-const { isPlainObject } = require("./type-utils");
-const { QueryBuilder } = require("./QueryBuilder");
-const { QueryContext } = require("./QueryContext");
-const { applyWhereConditions } = require("./applyWhereConditions");
-const { applyJoins } = require("./applyJoins");
-const { InlineFile, File } = require("./File");
-const { Duration } = require("./Duration");
-
-const {
-  applyLimit,
-  applyOffset,
-  applyOrderBy,
-} = require("./applyAdditionalQueryConstraints");
-const {
-  camelCaseObject,
-  snakeCaseObject,
-  upperCamelCase,
-} = require("./casing");
-const tracing = require("./tracing");
-const { DatabaseError } = require("./errors");
-
-/**
- * RelationshipConfig is a simple representation of a model field that
- * is a relationship. It is used by applyJoins and applyWhereConditions
- * to build the correct query.
- * @typedef {{
- *  relationshipType: "belongsTo" | "hasMany",
- *  foreignKey: string,
- *  referencesTable: string,
- * }} RelationshipConfig
- *
- * TableConfig is an object where the keys are relationship field names
- * (which don't exist in the database) and the values are RelationshipConfig
- * objects describing that relationship.
- * @typedef {Object.<string, RelationshipConfig} TableConfig
- *
- * TableConfigMap is mapping of database table names to TableConfig objects
- * @typedef {Object.<string, TableConfig>} TableConfigMap
- */
-
-class ModelAPI {
-  /**
-   * @param {string} tableName The name of the table this API is for
-   * @param {Function} _ Used to be a function that returns the default values for a row in this table. No longer used.
-   * @param {TableConfigMap} tableConfigMap
-   */
-  constructor(tableName, _, tableConfigMap = {}) {
-    this._tableName = tableName;
-    this._tableConfigMap = tableConfigMap;
-    this._modelName = upperCamelCase(this._tableName);
-  }
-
-  async create(values) {
-    const name = tracing.spanNameForModelAPI(this._modelName, "create");
-
-    return tracing.withSpan(name, () => {
-      const db = useDatabase();
-      return create(
-        db,
-        this._tableName,
-        this._tableConfigMap,
-        snakeCaseObject(values)
-      );
-    });
-  }
-
-  async findOne(where = {}) {
-    const name = tracing.spanNameForModelAPI(this._modelName, "findOne");
-    const db = useDatabase();
-
-    return tracing.withSpan(name, async (span) => {
-      let builder = db
-        .selectFrom(this._tableName)
-        .distinctOn(`${this._tableName}.id`)
-        .selectAll(this._tableName);
-
-      const context = new QueryContext([this._tableName], this._tableConfigMap);
-
-      builder = applyJoins(context, builder, where);
-      builder = applyWhereConditions(context, builder, where);
-
-      span.setAttribute("sql", builder.compile().sql);
-      const row = await builder.executeTakeFirst();
-      if (!row) {
-        return null;
-      }
-
-      return transformRichDataTypes(camelCaseObject(row));
-    });
-  }
-
-  async findMany(params) {
-    const name = tracing.spanNameForModelAPI(this._modelName, "findMany");
-    const db = useDatabase();
-    const where = params?.where || {};
-
-    return tracing.withSpan(name, async (span) => {
-      const context = new QueryContext([this._tableName], this._tableConfigMap);
-
-      let builder = db
-        .selectFrom((qb) => {
-          // We need to wrap this query as a sub query in the selectFrom because you cannot apply a different order by column when using distinct(id)
-          let builder = qb
-            .selectFrom(this._tableName)
-            .distinctOn(`${this._tableName}.id`)
-            .selectAll(this._tableName);
-
-          builder = applyJoins(context, builder, where);
-          builder = applyWhereConditions(context, builder, where);
-
-          builder = builder.as(this._tableName);
-
-          return builder;
-        })
-        .selectAll();
-
-      // The only constraints added to the main query are the orderBy, limit and offset as they are performed on the "outer" set
-      if (params?.limit) {
-        builder = applyLimit(context, builder, params.limit);
-      }
-
-      if (params?.offset) {
-        builder = applyOffset(context, builder, params.offset);
-      }
-
-      if (
-        params?.orderBy !== undefined &&
-        Object.keys(params?.orderBy).length > 0
-      ) {
-        builder = applyOrderBy(
-          context,
-          builder,
-          this._tableName,
-          params.orderBy
-        );
-      } else {
-        builder = builder.orderBy(`${this._tableName}.id`);
-      }
-
-      const query = builder;
-
-      span.setAttribute("sql", query.compile().sql);
-      const rows = await builder.execute();
-      return rows.map((x) => transformRichDataTypes(camelCaseObject(x)));
-    });
-  }
-
-  async update(where, values) {
-    const name = tracing.spanNameForModelAPI(this._modelName, "update");
-    const db = useDatabase();
-
-    return tracing.withSpan(name, async (span) => {
-      let builder = db.updateTable(this._tableName).returningAll();
-
-      // process input values
-      const keys = values ? Object.keys(values) : [];
-      const row = {};
-
-      for (const key of keys) {
-        const value = values[key];
-        if (Array.isArray(value)) {
-          row[key] = await Promise.all(
-            value.map(async (item) => {
-              if (item instanceof Duration) {
-                return item.toPostgres();
-              }
-              if (item instanceof InlineFile) {
-                const storedFile = await item.store();
-                return storedFile.toDbRecord();
-              }
-              if (item instanceof File) {
-                return item.toDbRecord();
-              }
-              return item;
-            })
-          );
-        } else if (value instanceof Duration) {
-          row[key] = value.toPostgres();
-        } else if (value instanceof InlineFile) {
-          const storedFile = await value.store();
-          row[key] = storedFile.toDbRecord();
-        } else if (value instanceof File) {
-          row[key] = value.toDbRecord();
-        } else {
-          row[key] = value;
-        }
-      }
-
-      builder = builder.set(snakeCaseObject(row));
-
-      const context = new QueryContext([this._tableName], this._tableConfigMap);
-
-      // TODO: support joins for update
-      builder = applyWhereConditions(context, builder, where);
-
-      span.setAttribute("sql", builder.compile().sql);
-
-      try {
-        const row = await builder.executeTakeFirstOrThrow();
-        return transformRichDataTypes(camelCaseObject(row));
-      } catch (e) {
-        throw new DatabaseError(e);
-      }
-    });
-  }
-
-  async delete(where) {
-    const name = tracing.spanNameForModelAPI(this._modelName, "delete");
-    const db = useDatabase();
-
-    return tracing.withSpan(name, async (span) => {
-      let builder = db.deleteFrom(this._tableName).returning(["id"]);
-
-      const context = new QueryContext([this._tableName], this._tableConfigMap);
-
-      // TODO: support joins for delete
-      builder = applyWhereConditions(context, builder, where);
-
-      span.setAttribute("sql", builder.compile().sql);
-      try {
-        const row = await builder.executeTakeFirstOrThrow();
-        return row.id;
-      } catch (e) {
-        throw new DatabaseError(e);
-      }
-    });
-  }
-
-  where(where) {
-    const db = useDatabase();
-
-    let builder = db
-      .selectFrom(this._tableName)
-      .distinctOn(`${this._tableName}.id`)
-      .selectAll(this._tableName);
-
-    const context = new QueryContext([this._tableName], this._tableConfigMap);
-
-    builder = applyJoins(context, builder, where);
-    builder = applyWhereConditions(context, builder, where);
-
-    return new QueryBuilder(this._tableName, context, builder);
-  }
-}
-
-async function create(conn, tableName, tableConfigs, values) {
-  try {
-    let query = conn.insertInto(tableName);
-
-    const keys = values ? Object.keys(values) : [];
-    const tableConfig = tableConfigs[tableName] || {};
-    const hasManyRecords = [];
-
-    if (keys.length === 0) {
-      // See https://github.com/kysely-org/kysely/issues/685#issuecomment-1711240534
-      query = query.expression(sql`default values`);
-    } else {
-      const row = {};
-      for (const key of keys) {
-        const value = values[key];
-        const columnConfig = tableConfig[key];
-
-        if (!columnConfig) {
-          if (Array.isArray(value)) {
-            row[key] = await Promise.all(
-              value.map(async (item) => {
-                if (item instanceof Duration) {
-                  return item.toPostgres();
-                }
-                if (item instanceof InlineFile) {
-                  const storedFile = await item.store();
-                  return storedFile.toDbRecord();
-                }
-                if (item instanceof File) {
-                  return item.toDbRecord();
-                }
-                return item;
-              })
-            );
-          } else if (value instanceof Duration) {
-            row[key] = value.toPostgres();
-          } else if (value instanceof InlineFile) {
-            const storedFile = await value.store();
-            row[key] = storedFile.toDbRecord();
-          } else if (value instanceof File) {
-            row[key] = value.toDbRecord();
-          } else {
-            row[key] = value;
-          }
-          continue;
-        }
-
-        switch (columnConfig.relationshipType) {
-          case "belongsTo":
-            if (!isPlainObject(value)) {
-              throw new Error(
-                `non-object provided for field ${key} of ${tableName}`
-              );
-            }
-
-            if (isReferencingExistingRecord(value)) {
-              row[columnConfig.foreignKey] = value.id;
-              break;
-            }
-
-            const created = await create(
-              conn,
-              columnConfig.referencesTable,
-              tableConfigs,
-              value
-            );
-            row[columnConfig.foreignKey] = created.id;
-            break;
-
-          case "hasMany":
-            if (!Array.isArray(value)) {
-              throw new Error(
-                `non-array provided for has-many field ${key} of ${tableName}`
-              );
-            }
-            for (const v of value) {
-              hasManyRecords.push({
-                key,
-                value: v,
-                columnConfig,
-              });
-            }
-            break;
-          default:
-            throw new Error(
-              `unsupported relationship type - ${tableName}.${key} (${columnConfig.relationshipType})`
-            );
-        }
-      }
-
-      query = query.values(row);
-    }
-
-    const created = await query.returningAll().executeTakeFirstOrThrow();
-
-    await Promise.all(
-      hasManyRecords.map(async ({ key, value, columnConfig }) => {
-        if (!isPlainObject(value)) {
-          throw new Error(
-            `non-object provided for field ${key} of ${tableName}`
-          );
-        }
-
-        if (isReferencingExistingRecord(value)) {
-          throw new Error(
-            `nested update as part of create not supported for ${key} of ${tableConfig}`
-          );
-        }
-
-        return create(conn, columnConfig.referencesTable, tableConfigs, {
-          ...value,
-          [columnConfig.foreignKey]: created.id,
-        });
-      })
-    );
-
-    return transformRichDataTypes(created);
-  } catch (e) {
-    throw new DatabaseError(e);
-  }
-}
-
-module.exports = {
-  ModelAPI,
-  DatabaseError,
-};