@teamkeel/functions-runtime 0.434.1 → 0.435.0

package/dist/index.cjs

@@ -1560,6 +1560,221 @@ var QueryBuilder = class _QueryBuilder {
       return rows.map((x) => transformRichDataTypes(camelCaseObject(x)));
     });
   }
+  /**
+   * Execute query with pagination support.
+   * Returns results along with pageInfo metadata.
+   * @param {Object} params - Pagination parameters
+   * @param {number} [params.first] - Number of items for cursor pagination (forward)
+   * @param {string} [params.after] - Cursor for forward pagination
+   * @param {number} [params.last] - Number of items for cursor pagination (backward)
+   * @param {string} [params.before] - Cursor for backward pagination
+   * @param {number} [params.limit] - Page size for offset pagination
+   * @param {number} [params.offset] - Offset for offset pagination
+   * @param {Object} [params.orderBy] - Ordering specification
+   * @returns {Promise<{results: any[], pageInfo: Object}>}
+   */
+  async findManyWithPageInfo(params = {}) {
+    const name = spanNameForModelAPI(
+      this._modelName,
+      "findManyWithPageInfo"
+    );
+    const db = useDatabase();
+    return withSpan(name, async (span) => {
+      const context6 = new QueryContext([this._tableName], this._tableConfigMap);
+      const isOffsetPagination = params.limit != null && params.limit > 0;
+      const isBackward = params.last != null && params.last > 0;
+      const DEFAULT_PAGE_SIZE = 50;
+      let limit;
+      if (isOffsetPagination) {
+        limit = params.limit;
+      } else if (isBackward) {
+        limit = params.last;
+      } else {
+        limit = params.first ?? DEFAULT_PAGE_SIZE;
+      }
+      const countQuery = db.selectFrom((qb) => this._db.as(this._tableName)).select(db.fn.countAll().as("total"));
+      const countResult = await countQuery.executeTakeFirst();
+      const totalCount = Number(countResult?.total ?? 0);
+      let builder = db.selectFrom((qb) => this._db.as(this._tableName)).selectAll();
+      let normalizedOrderBy = null;
+      if (params.orderBy) {
+        if (Array.isArray(params.orderBy)) {
+          normalizedOrderBy = {};
+          for (const item of params.orderBy) {
+            for (const [key, dir] of Object.entries(item)) {
+              normalizedOrderBy[key] = dir;
+            }
+          }
+        } else {
+          normalizedOrderBy = params.orderBy;
+        }
+      }
+      const orderByFields = [];
+      const hasCustomOrderBy = normalizedOrderBy !== null && Object.keys(normalizedOrderBy).length > 0;
+      if (hasCustomOrderBy) {
+        for (const [key, dir] of Object.entries(normalizedOrderBy)) {
+          orderByFields.push({
+            field: key,
+            direction: String(dir).toLowerCase()
+          });
+        }
+      }
+      orderByFields.push({ field: "id", direction: "asc" });
+      if (hasCustomOrderBy) {
+        const effectiveOrderBy = isBackward ? Object.fromEntries(
+          Object.entries(normalizedOrderBy).map(([key, dir]) => [
+            key,
+            String(dir).toLowerCase() === "asc" ? "desc" : "asc"
+          ])
+        ) : normalizedOrderBy;
+        builder = applyOrderBy(
+          context6,
+          builder,
+          this._tableName,
+          effectiveOrderBy
+        );
+        const idDirection = isBackward ? "desc" : "asc";
+        builder = builder.orderBy(`${this._tableName}.id`, idDirection);
+      } else {
+        const direction = isBackward ? "desc" : "asc";
+        builder = builder.orderBy(`${this._tableName}.id`, direction);
+      }
+      const cursor = isBackward ? params.before : params.after;
+      if (cursor) {
+        const primaryField = orderByFields[0];
+        const primaryFieldCol = (0, import_change_case.snakeCase)(primaryField.field);
+        const cursorLookup = await db.selectFrom((qb) => this._db.as(this._tableName)).select([primaryFieldCol, "id"]).where(`${this._tableName}.id`, "=", cursor).limit(1).executeTakeFirst();
+        if (cursorLookup) {
+          const primaryValue = cursorLookup[primaryFieldCol];
+          const cursorId = cursorLookup.id;
+          let primaryOp;
+          if (primaryField.direction === "asc") {
+            primaryOp = isBackward ? "<" : ">";
+          } else {
+            primaryOp = isBackward ? ">" : "<";
+          }
+          const idOp = isBackward ? "<" : ">";
+          if (primaryValue === null) {
+            if (primaryOp === ">") {
+              builder = builder.where(
+                (eb) => eb.or([
+                  eb(`${this._tableName}.${primaryFieldCol}`, "is not", null),
+                  eb.and([
+                    eb(`${this._tableName}.${primaryFieldCol}`, "is", null),
+                    eb(`${this._tableName}.id`, idOp, cursorId)
+                  ])
+                ])
+              );
+            } else {
+              builder = builder.where(
+                (eb) => eb.and([
+                  eb(`${this._tableName}.${primaryFieldCol}`, "is", null),
+                  eb(`${this._tableName}.id`, idOp, cursorId)
+                ])
+              );
+            }
+          } else {
+            builder = builder.where(
+              (eb) => eb.or([
+                eb(
+                  `${this._tableName}.${primaryFieldCol}`,
+                  primaryOp,
+                  primaryValue
+                ),
+                eb.and([
+                  eb(
+                    `${this._tableName}.${primaryFieldCol}`,
+                    "=",
+                    primaryValue
+                  ),
+                  eb(`${this._tableName}.id`, idOp, cursorId)
+                ])
+              ])
+            );
+          }
+        } else {
+          builder = builder.where(
+            `${this._tableName}.id`,
+            "=",
+            "___NONEXISTENT_ID___"
+          );
+        }
+      }
+      if (limit != null) {
+        builder = applyLimit(context6, builder, limit);
+      }
+      if (isOffsetPagination && params.offset) {
+        builder = applyOffset(context6, builder, params.offset);
+      }
+      span.setAttribute("sql", builder.compile().sql);
+      let rows = await builder.execute();
+      if (isBackward) {
+        rows = rows.reverse();
+      }
+      const results = rows.map(
+        (x) => transformRichDataTypes(camelCaseObject(x))
+      );
+      let hasNextPage = false;
+      if (isOffsetPagination) {
+        hasNextPage = totalCount > (params.offset || 0) + limit;
+      } else if (limit != null && results.length === limit && results.length > 0) {
+        const lastResult = results[results.length - 1];
+        const primaryField = orderByFields[0];
+        const primaryFieldCol = (0, import_change_case.snakeCase)(primaryField.field);
+        const primaryValue = lastResult[primaryField.field];
+        const lastId = lastResult.id;
+        const primaryOp = primaryField.direction === "asc" ? ">" : "<";
+        let nextCheckQuery = db.selectFrom((qb) => this._db.as(this._tableName)).select("id").limit(1);
+        if (primaryValue === null) {
+          if (primaryOp === ">") {
+            nextCheckQuery = nextCheckQuery.where(
+              (eb) => eb.or([
+                eb(`${this._tableName}.${primaryFieldCol}`, "is not", null),
+                eb.and([
+                  eb(`${this._tableName}.${primaryFieldCol}`, "is", null),
+                  eb(`${this._tableName}.id`, ">", lastId)
+                ])
+              ])
+            );
+          } else {
+            nextCheckQuery = nextCheckQuery.where(
+              (eb) => eb.and([
+                eb(`${this._tableName}.${primaryFieldCol}`, "is", null),
+                eb(`${this._tableName}.id`, ">", lastId)
+              ])
+            );
+          }
+        } else {
+          nextCheckQuery = nextCheckQuery.where(
+            (eb) => eb.or([
+              eb(
+                `${this._tableName}.${primaryFieldCol}`,
+                primaryOp,
+                primaryValue
+              ),
+              eb.and([
+                eb(`${this._tableName}.${primaryFieldCol}`, "=", primaryValue),
+                eb(`${this._tableName}.id`, ">", lastId)
+              ])
+            ])
+          );
+        }
+        const nextRecord = await nextCheckQuery.executeTakeFirst();
+        hasNextPage = nextRecord != null;
+      }
+      const pageInfo = {
+        count: results.length,
+        totalCount,
+        hasNextPage,
+        startCursor: results.length > 0 ? results[0].id : "",
+        endCursor: results.length > 0 ? results[results.length - 1].id : ""
+      };
+      if (isOffsetPagination && limit > 0) {
+        pageInfo.pageNumber = 1 + Math.floor((params.offset || 0) / limit);
+      }
+      return { results, pageInfo };
+    });
+  }
 };
 
 // src/ModelAPI.js
@@ -2571,7 +2786,11 @@ function tryExecuteFunction({ request, db, permitted, permissionFns, actionType,
           if (fnResult != null) {
             switch (actionType) {
               case PROTO_ACTION_TYPES.LIST:
-                rowsForPermissions = fnResult;
+                if (Array.isArray(fnResult)) {
+                  rowsForPermissions = fnResult;
+                } else if (fnResult.results != null && Array.isArray(fnResult.results)) {
+                  rowsForPermissions = fnResult.results;
+                }
                 break;
               case PROTO_ACTION_TYPES.DELETE:
                 rowsForPermissions = [{ id: fnResult }];