@webiny/db-dynamodb 0.0.0-unstable.78f581c1d2 → 0.0.0-unstable.7be00a75a9

package/utils/put.js

@@ -0,0 +1,10 @@
+const put = async (params)=>{
+    const { entity, item } = params;
+    return await entity.put(item, {
+        execute: true,
+        strictSchemaCheck: false
+    });
+};
+export { put };
+
+//# sourceMappingURL=put.js.map

package/utils/put.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils/put.js","sources":["../../src/utils/put.ts"],"sourcesContent":["import type { Entity } from \"~/toolbox.js\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\n\nexport type IPutParamsItem<T extends GenericRecord = GenericRecord> = {\n    PK: string;\n    SK: string;\n    [key: string]: any;\n} & T;\n\nexport interface IPutParams<T extends GenericRecord = GenericRecord> {\n    entity: Entity;\n    item: IPutParamsItem<T>;\n}\n\nexport const put = async <T extends GenericRecord = GenericRecord>(params: IPutParams<T>) => {\n    const { entity, item } = params;\n\n    return await entity.put(item, {\n        execute: true,\n        strictSchemaCheck: false\n    });\n};\n"],"names":["put","params","entity","item"],"mappings":"AAcO,MAAMA,MAAM,OAAgDC;IAC/D,MAAM,EAAEC,MAAM,EAAEC,IAAI,EAAE,GAAGF;IAEzB,OAAO,MAAMC,OAAO,GAAG,CAACC,MAAM;QAC1B,SAAS;QACT,mBAAmB;IACvB;AACJ"}

package/utils/query.d.ts

@@ -1,12 +1,12 @@
-import { queryOptions as DynamoDBToolboxQueryOptions } from "dynamodb-toolbox/dist/classes/Table";
-import { Entity } from "dynamodb-toolbox";
+import type { Entity, EntityQueryOptions } from "../toolbox.js";
+import type { GenericRecord } from "@webiny/api/types.js";
 export interface QueryAllParams {
     entity: Entity<any>;
     partitionKey: string;
-    options?: DynamoDBToolboxQueryOptions;
+    options?: EntityQueryOptions;
 }
 export interface QueryOneParams extends QueryAllParams {
-    options?: Omit<DynamoDBToolboxQueryOptions, "limit">;
+    options?: Omit<EntityQueryOptions, "limit">;
 }
 export interface QueryParams extends QueryAllParams {
     previous?: any;
@@ -15,18 +15,24 @@ export interface QueryResult<T> {
     result: any | null;
     items: T[];
 }
-export declare type DbItem<T> = T & {
-    PK: string;
-    SK: string;
-    TYPE: string;
-    GSI1_PK?: string;
-    GSI1_SK?: string;
-};
 /**
  * Will run the query to fetch the first possible item from the database.
  */
-export declare const queryOne: <T>(params: QueryOneParams) => Promise<DbItem<T> | null>;
+export declare const queryOne: <T>(params: QueryOneParams) => Promise<T | null>;
+export declare const queryOneClean: <T>(params: QueryOneParams) => Promise<T | null>;
 /**
- * Will run the query to fetch the results no matter how much iterations it needs to go through.
+ * Will run the query to fetch the results no matter how many iterations it needs to go through.
  */
-export declare const queryAll: <T>(params: QueryAllParams) => Promise<DbItem<T>[]>;
+export declare const queryAll: <T>(params: QueryAllParams) => Promise<T[]>;
+export declare const queryAllClean: <T>(params: QueryAllParams) => Promise<T[]>;
+export interface IQueryPageResponse<T> {
+    items: T[];
+    lastEvaluatedKey: GenericRecord;
+}
+export declare const queryPerPage: <T>(params: QueryAllParams) => Promise<IQueryPageResponse<T>>;
+export declare const queryPerPageClean: <T>(params: QueryAllParams) => Promise<IQueryPageResponse<T>>;
+/**
+ * Will run the query to fetch the results no matter how many iterations it needs to go through.
+ * Results of each iteration will be passed to the provided callback
+ */
+export declare const queryAllWithCallback: <T>(params: QueryAllParams, callback: (items: T[]) => Promise<void>) => Promise<void>;

package/utils/query.js

@@ -1,119 +1,95 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.queryOne = exports.queryAll = void 0;
-
-var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
-
-var _error = _interopRequireDefault(require("@webiny/error"));
-
-/**
- * Will run query only once. Pass the previous to run the query again to fetch new data.
- * It returns the result and the items it found.
- * Result is required to fetch the items that were not fetched in the previous run.
- */
-const query = async params => {
-  const {
-    entity,
-    previous,
-    partitionKey,
-    options
-  } = params;
-  let result;
-  /**
-   * In case there is no previous result we must make a new query.
-   * This is the first query on the given partition key.
-   */
-
-  if (!previous) {
-    result = await entity.query(partitionKey, options);
-  } else if (typeof previous.next === "function") {
-    /**
-     * In case we have a previous result and it has a next method, we run it.
-     * In case result of the next method is false, it means it has nothing else to read
-     * and we return a null to keep the query from repeating.
-     */
-    result = await previous.next();
-
-    if (result === false) {
-      return {
+import error from "@webiny/error";
+import { cleanupItem, cleanupItems } from "./cleanup.js";
+const query = async (params)=>{
+    const { entity, previous, partitionKey, options } = params;
+    let result;
+    if (previous) if ("function" != typeof previous.next) return {
         result: null,
         items: []
-      };
+    };
+    else {
+        result = await previous.next();
+        if (false === result) return {
+            result: null,
+            items: []
+        };
     }
-  } else {
-    /**
-     * This could probably never happen but keep it here just in case to break the query loop.
-     * Basically, either previous does not exist or it exists and it does not have the next method
-     * and at that point a result returned will be null and loop should not start again.
-     */
+    else result = await entity.query(partitionKey, options);
+    if (!result || !result.Items || !Array.isArray(result.Items)) throw new error("Error when querying for content entries - no result.", "QUERY_ERROR", {
+        partitionKey,
+        options
+    });
     return {
-      result: null,
-      items: []
+        result,
+        items: result.Items
     };
-  }
-  /**
-   * We expect the result to contain an Items array and if not, something went wrong, very wrong.
-   */
-
-
-  if (!result || !result.Items || !Array.isArray(result.Items)) {
-    throw new _error.default("Error when querying for content entries - no result.", "QUERY_ERROR", {
-      partitionKey,
-      options
+};
+const queryOne = async (params)=>{
+    const { items } = await query({
+        ...params,
+        options: {
+            ...params.options || {},
+            limit: 1
+        }
     });
-  }
-
-  return {
-    result,
-    items: result.Items
-  };
+    const item = items.shift();
+    return item ? item : null;
 };
-/**
- * Will run the query to fetch the first possible item from the database.
- */
-
-
-const queryOne = async params => {
-  const {
-    items
-  } = await query((0, _objectSpread2.default)((0, _objectSpread2.default)({}, params), {}, {
-    options: (0, _objectSpread2.default)((0, _objectSpread2.default)({}, params.options || {}), {}, {
-      limit: 1
-    })
-  }));
-  const item = items.shift();
-  return item ? item : null;
+const queryOneClean = async (params)=>{
+    const result = await queryOne(params);
+    if (!result) return null;
+    return cleanupItem(params.entity, result);
 };
-/**
- * Will run the query to fetch the results no matter how much iterations it needs to go through.
- */
-
-
-exports.queryOne = queryOne;
-
-const queryAll = async params => {
-  const items = [];
-  let results;
-  let previousResult = undefined;
-
-  while (results = await query((0, _objectSpread2.default)((0, _objectSpread2.default)({}, params), {}, {
-    previous: previousResult
-  }))) {
-    items.push(...results.items);
-
-    if (!results.result) {
-      return items;
+const queryAll = async (params)=>{
+    const items = [];
+    let results;
+    let previousResult;
+    while(results = await query({
+        ...params,
+        previous: previousResult
+    })){
+        items.push(...results.items);
+        if (!results.result) break;
+        previousResult = results.result;
+    }
+    return items;
+};
+const queryAllClean = async (params)=>{
+    const results = await queryAll(params);
+    return cleanupItems(params.entity, results);
+};
+const queryPerPage = async (params)=>{
+    const result = await query({
+        ...params,
+        options: {
+            ...params.options,
+            limit: params.options?.limit || 50
+        }
+    });
+    return {
+        items: result.items,
+        lastEvaluatedKey: result.result?.LastEvaluatedKey
+    };
+};
+const queryPerPageClean = async (params)=>{
+    const result = await queryPerPage(params);
+    return {
+        items: cleanupItems(params.entity, result.items),
+        lastEvaluatedKey: result.lastEvaluatedKey
+    };
+};
+const queryAllWithCallback = async (params, callback)=>{
+    let results;
+    let previousResult;
+    while(results = await query({
+        ...params,
+        previous: previousResult
+    })){
+        if (!results.result) break;
+        await callback(results.items);
+        previousResult = results.result;
     }
-
-    previousResult = results.result;
-  }
-
-  return items;
 };
+export { queryAll, queryAllClean, queryAllWithCallback, queryOne, queryOneClean, queryPerPage, queryPerPageClean };
 
-exports.queryAll = queryAll;
+//# sourceMappingURL=query.js.map

package/utils/query.js.map

@@ -1 +1 @@
-{"version":3,"names":["query","params","entity","previous","partitionKey","options","result","next","items","Items","Array","isArray","WebinyError","queryOne","limit","item","shift","queryAll","results","previousResult","undefined","push"],"sources":["query.ts"],"sourcesContent":["import { queryOptions as DynamoDBToolboxQueryOptions } from \"dynamodb-toolbox/dist/classes/Table\";\nimport WebinyError from \"@webiny/error\";\nimport { Entity } from \"dynamodb-toolbox\";\n\nexport interface QueryAllParams {\n    entity: Entity<any>;\n    partitionKey: string;\n    options?: DynamoDBToolboxQueryOptions;\n}\n\nexport interface QueryOneParams extends QueryAllParams {\n    options?: Omit<DynamoDBToolboxQueryOptions, \"limit\">;\n}\n\nexport interface QueryParams extends QueryAllParams {\n    previous?: any;\n}\n\nexport interface QueryResult<T> {\n    result: any | null;\n    items: T[];\n}\n\nexport type DbItem<T> = T & {\n    PK: string;\n    SK: string;\n    TYPE: string;\n    GSI1_PK?: string;\n    GSI1_SK?: string;\n};\n\n/**\n * Will run query only once. Pass the previous to run the query again to fetch new data.\n * It returns the result and the items it found.\n * Result is required to fetch the items that were not fetched in the previous run.\n */\nconst query = async <T>(params: QueryParams): Promise<QueryResult<T>> => {\n    const { entity, previous, partitionKey, options } = params;\n    let result;\n    /**\n     * In case there is no previous result we must make a new query.\n     * This is the first query on the given partition key.\n     */\n    if (!previous) {\n        result = await entity.query(partitionKey, options);\n    } else if (typeof previous.next === \"function\") {\n        /**\n         * In case we have a previous result and it has a next method, we run it.\n         * In case result of the next method is false, it means it has nothing else to read\n         * and we return a null to keep the query from repeating.\n         */\n        result = await previous.next();\n        if (result === false) {\n            return {\n                result: null,\n                items: []\n            };\n        }\n    } else {\n        /**\n         * This could probably never happen but keep it here just in case to break the query loop.\n         * Basically, either previous does not exist or it exists and it does not have the next method\n         * and at that point a result returned will be null and loop should not start again.\n         */\n        return {\n            result: null,\n            items: []\n        };\n    }\n    /**\n     * We expect the result to contain an Items array and if not, something went wrong, very wrong.\n     */\n    if (!result || !result.Items || !Array.isArray(result.Items)) {\n        throw new WebinyError(\n            \"Error when querying for content entries - no result.\",\n            \"QUERY_ERROR\",\n            {\n                partitionKey,\n                options\n            }\n        );\n    }\n    return {\n        result,\n        items: result.Items\n    };\n};\n/**\n * Will run the query to fetch the first possible item from the database.\n */\nexport const queryOne = async <T>(params: QueryOneParams): Promise<DbItem<T> | null> => {\n    const { items } = await query<DbItem<T>>({\n        ...params,\n        options: {\n            ...(params.options || {}),\n            limit: 1\n        }\n    });\n    const item = items.shift();\n    return item ? item : null;\n};\n/**\n * Will run the query to fetch the results no matter how much iterations it needs to go through.\n */\nexport const queryAll = async <T>(params: QueryAllParams): Promise<DbItem<T>[]> => {\n    const items: DbItem<T>[] = [];\n    let results: QueryResult<DbItem<T>>;\n    let previousResult: any = undefined;\n    while ((results = await query({ ...params, previous: previousResult }))) {\n        items.push(...results.items);\n        if (!results.result) {\n            return items;\n        }\n        previousResult = results.result;\n    }\n    return items;\n};\n"],"mappings":";;;;;;;;;;;AACA;;AA8BA;AACA;AACA;AACA;AACA;AACA,MAAMA,KAAK,GAAG,MAAUC,MAAV,IAA2D;EACrE,MAAM;IAAEC,MAAF;IAAUC,QAAV;IAAoBC,YAApB;IAAkCC;EAAlC,IAA8CJ,MAApD;EACA,IAAIK,MAAJ;EACA;AACJ;AACA;AACA;;EACI,IAAI,CAACH,QAAL,EAAe;IACXG,MAAM,GAAG,MAAMJ,MAAM,CAACF,KAAP,CAAaI,YAAb,EAA2BC,OAA3B,CAAf;EACH,CAFD,MAEO,IAAI,OAAOF,QAAQ,CAACI,IAAhB,KAAyB,UAA7B,EAAyC;IAC5C;AACR;AACA;AACA;AACA;IACQD,MAAM,GAAG,MAAMH,QAAQ,CAACI,IAAT,EAAf;;IACA,IAAID,MAAM,KAAK,KAAf,EAAsB;MAClB,OAAO;QACHA,MAAM,EAAE,IADL;QAEHE,KAAK,EAAE;MAFJ,CAAP;IAIH;EACJ,CAbM,MAaA;IACH;AACR;AACA;AACA;AACA;IACQ,OAAO;MACHF,MAAM,EAAE,IADL;MAEHE,KAAK,EAAE;IAFJ,CAAP;EAIH;EACD;AACJ;AACA;;;EACI,IAAI,CAACF,MAAD,IAAW,CAACA,MAAM,CAACG,KAAnB,IAA4B,CAACC,KAAK,CAACC,OAAN,CAAcL,MAAM,CAACG,KAArB,CAAjC,EAA8D;IAC1D,MAAM,IAAIG,cAAJ,CACF,sDADE,EAEF,aAFE,EAGF;MACIR,YADJ;MAEIC;IAFJ,CAHE,CAAN;EAQH;;EACD,OAAO;IACHC,MADG;IAEHE,KAAK,EAAEF,MAAM,CAACG;EAFX,CAAP;AAIH,CAlDD;AAmDA;AACA;AACA;;;AACO,MAAMI,QAAQ,GAAG,MAAUZ,MAAV,IAAgE;EACpF,MAAM;IAAEO;EAAF,IAAY,MAAMR,KAAK,6DACtBC,MADsB;IAEzBI,OAAO,8DACCJ,MAAM,CAACI,OAAP,IAAkB,EADnB;MAEHS,KAAK,EAAE;IAFJ;EAFkB,GAA7B;EAOA,MAAMC,IAAI,GAAGP,KAAK,CAACQ,KAAN,EAAb;EACA,OAAOD,IAAI,GAAGA,IAAH,GAAU,IAArB;AACH,CAVM;AAWP;AACA;AACA;;;;;AACO,MAAME,QAAQ,GAAG,MAAUhB,MAAV,IAA2D;EAC/E,MAAMO,KAAkB,GAAG,EAA3B;EACA,IAAIU,OAAJ;EACA,IAAIC,cAAmB,GAAGC,SAA1B;;EACA,OAAQF,OAAO,GAAG,MAAMlB,KAAK,6DAAMC,MAAN;IAAcE,QAAQ,EAAEgB;EAAxB,GAA7B,EAAyE;IACrEX,KAAK,CAACa,IAAN,CAAW,GAAGH,OAAO,CAACV,KAAtB;;IACA,IAAI,CAACU,OAAO,CAACZ,MAAb,EAAqB;MACjB,OAAOE,KAAP;IACH;;IACDW,cAAc,GAAGD,OAAO,CAACZ,MAAzB;EACH;;EACD,OAAOE,KAAP;AACH,CAZM"}
+{"version":3,"file":"utils/query.js","sources":["../../src/utils/query.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport type { Entity, EntityQueryOptions } from \"~/toolbox.js\";\nimport { cleanupItem, cleanupItems } from \"~/utils/cleanup.js\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\n\nexport interface QueryAllParams {\n    entity: Entity<any>;\n    partitionKey: string;\n    options?: EntityQueryOptions;\n}\n\nexport interface QueryOneParams extends QueryAllParams {\n    options?: Omit<EntityQueryOptions, \"limit\">;\n}\n\nexport interface QueryParams extends QueryAllParams {\n    previous?: any;\n}\n\nexport interface QueryResult<T> {\n    result: any | null;\n    items: T[];\n}\n\n/**\n * Will run query only once. Pass the previous to run the query again to fetch new data.\n * It returns the result and the items it found.\n * Result is required to fetch the items that were not fetched in the previous run.\n */\nconst query = async <T>(params: QueryParams): Promise<QueryResult<T>> => {\n    const { entity, previous, partitionKey, options } = params;\n    let result;\n    /**\n     * In case there is no previous result we must make a new query.\n     * This is the first query on the given partition key.\n     */\n    if (!previous) {\n        // @ts-expect-error\n        result = await entity.query(partitionKey, options);\n    } else if (typeof previous.next === \"function\") {\n        /**\n         * In case we have a previous result and it has a next method, we run it.\n         * In case result of the next method is false, it means it has nothing else to read\n         * and we return a null to keep the query from repeating.\n         */\n        result = await previous.next();\n        if (result === false) {\n            return {\n                result: null,\n                items: []\n            };\n        }\n    } else {\n        /**\n         * This could probably never happen but keep it here just in case to break the query loop.\n         * Basically, either previous does not exist or it exists and it does not have the next method\n         * and at that point a result returned will be null and loop should not start again.\n         */\n        return {\n            result: null,\n            items: []\n        };\n    }\n    /**\n     * We expect the result to contain an Items array and if not, something went wrong, very wrong.\n     */\n    if (!result || !result.Items || !Array.isArray(result.Items)) {\n        throw new WebinyError(\n            \"Error when querying for content entries - no result.\",\n            \"QUERY_ERROR\",\n            {\n                partitionKey,\n                options\n            }\n        );\n    }\n    return {\n        result,\n        items: result.Items\n    };\n};\n/**\n * Will run the query to fetch the first possible item from the database.\n */\nexport const queryOne = async <T>(params: QueryOneParams): Promise<T | null> => {\n    const { items } = await query<T>({\n        ...params,\n        options: {\n            ...(params.options || {}),\n            limit: 1\n        }\n    });\n    const item = items.shift();\n    return item ? item : null;\n};\n\nexport const queryOneClean = async <T>(params: QueryOneParams): Promise<T | null> => {\n    const result = await queryOne<T>(params);\n    if (!result) {\n        return null;\n    }\n    return cleanupItem(params.entity, result);\n};\n/**\n * Will run the query to fetch the results no matter how many iterations it needs to go through.\n */\nexport const queryAll = async <T>(params: QueryAllParams): Promise<T[]> => {\n    const items: T[] = [];\n    let results: QueryResult<T>;\n    let previousResult: any = undefined;\n    while ((results = await query({ ...params, previous: previousResult }))) {\n        items.push(...results.items);\n        if (!results.result) {\n            return items;\n        }\n        previousResult = results.result;\n    }\n    return items;\n};\n\nexport const queryAllClean = async <T>(params: QueryAllParams): Promise<T[]> => {\n    const results = await queryAll<T>(params);\n    return cleanupItems(params.entity, results);\n};\n\nexport interface IQueryPageResponse<T> {\n    items: T[];\n    lastEvaluatedKey: GenericRecord;\n}\n\nexport const queryPerPage = async <T>(params: QueryAllParams): Promise<IQueryPageResponse<T>> => {\n    const result = await query<T>({\n        ...params,\n        options: {\n            ...params.options,\n            limit: params.options?.limit || 50\n        }\n    });\n\n    return {\n        items: result.items,\n        lastEvaluatedKey: result.result?.LastEvaluatedKey\n    };\n};\n\nexport const queryPerPageClean = async <T>(\n    params: QueryAllParams\n): Promise<IQueryPageResponse<T>> => {\n    const result = await queryPerPage<T>(params);\n    return {\n        items: cleanupItems<T>(params.entity, result.items),\n        lastEvaluatedKey: result.lastEvaluatedKey\n    };\n};\n\n/**\n * Will run the query to fetch the results no matter how many iterations it needs to go through.\n * Results of each iteration will be passed to the provided callback\n */\nexport const queryAllWithCallback = async <T>(\n    params: QueryAllParams,\n    callback: (items: T[]) => Promise<void>\n): Promise<void> => {\n    let results: QueryResult<T>;\n    let previousResult: any = undefined;\n    while ((results = await query({ ...params, previous: previousResult }))) {\n        if (!results.result) {\n            break;\n        }\n        await callback(results.items);\n        previousResult = results.result;\n    }\n};\n"],"names":["query","params","entity","previous","partitionKey","options","result","Array","WebinyError","queryOne","items","item","queryOneClean","cleanupItem","queryAll","results","previousResult","queryAllClean","cleanupItems","queryPerPage","queryPerPageClean","queryAllWithCallback","callback"],"mappings":";;AA6BA,MAAMA,QAAQ,OAAUC;IACpB,MAAM,EAAEC,MAAM,EAAEC,QAAQ,EAAEC,YAAY,EAAEC,OAAO,EAAE,GAAGJ;IACpD,IAAIK;IAKJ,IAAKH,UAGE,IAAI,AAAyB,cAAzB,OAAOA,SAAS,IAAI,EAmB3B,OAAO;QACH,QAAQ;QACR,OAAO,EAAE;IACb;SAtB4C;QAM5CG,SAAS,MAAMH,SAAS,IAAI;QAC5B,IAAIG,AAAW,UAAXA,QACA,OAAO;YACH,QAAQ;YACR,OAAO,EAAE;QACb;IAER;SAdIA,SAAS,MAAMJ,OAAO,KAAK,CAACE,cAAcC;IA4B9C,IAAI,CAACC,UAAU,CAACA,OAAO,KAAK,IAAI,CAACC,MAAM,OAAO,CAACD,OAAO,KAAK,GACvD,MAAM,IAAIE,MACN,wDACA,eACA;QACIJ;QACAC;IACJ;IAGR,OAAO;QACHC;QACA,OAAOA,OAAO,KAAK;IACvB;AACJ;AAIO,MAAMG,WAAW,OAAUR;IAC9B,MAAM,EAAES,KAAK,EAAE,GAAG,MAAMV,MAAS;QAC7B,GAAGC,MAAM;QACT,SAAS;YACL,GAAIA,OAAO,OAAO,IAAI,CAAC,CAAC;YACxB,OAAO;QACX;IACJ;IACA,MAAMU,OAAOD,MAAM,KAAK;IACxB,OAAOC,OAAOA,OAAO;AACzB;AAEO,MAAMC,gBAAgB,OAAUX;IACnC,MAAMK,SAAS,MAAMG,SAAYR;IACjC,IAAI,CAACK,QACD,OAAO;IAEX,OAAOO,YAAYZ,OAAO,MAAM,EAAEK;AACtC;AAIO,MAAMQ,WAAW,OAAUb;IAC9B,MAAMS,QAAa,EAAE;IACrB,IAAIK;IACJ,IAAIC;IACJ,MAAQD,UAAU,MAAMf,MAAM;QAAE,GAAGC,MAAM;QAAE,UAAUe;IAAe,GAAK;QACrEN,MAAM,IAAI,IAAIK,QAAQ,KAAK;QAC3B,IAAI,CAACA,QAAQ,MAAM,EACf;QAEJC,iBAAiBD,QAAQ,MAAM;IACnC;IACA,OAAOL;AACX;AAEO,MAAMO,gBAAgB,OAAUhB;IACnC,MAAMc,UAAU,MAAMD,SAAYb;IAClC,OAAOiB,aAAajB,OAAO,MAAM,EAAEc;AACvC;AAOO,MAAMI,eAAe,OAAUlB;IAClC,MAAMK,SAAS,MAAMN,MAAS;QAC1B,GAAGC,MAAM;QACT,SAAS;YACL,GAAGA,OAAO,OAAO;YACjB,OAAOA,OAAO,OAAO,EAAE,SAAS;QACpC;IACJ;IAEA,OAAO;QACH,OAAOK,OAAO,KAAK;QACnB,kBAAkBA,OAAO,MAAM,EAAE;IACrC;AACJ;AAEO,MAAMc,oBAAoB,OAC7BnB;IAEA,MAAMK,SAAS,MAAMa,aAAgBlB;IACrC,OAAO;QACH,OAAOiB,aAAgBjB,OAAO,MAAM,EAAEK,OAAO,KAAK;QAClD,kBAAkBA,OAAO,gBAAgB;IAC7C;AACJ;AAMO,MAAMe,uBAAuB,OAChCpB,QACAqB;IAEA,IAAIP;IACJ,IAAIC;IACJ,MAAQD,UAAU,MAAMf,MAAM;QAAE,GAAGC,MAAM;QAAE,UAAUe;IAAe,GAAK;QACrE,IAAI,CAACD,QAAQ,MAAM,EACf;QAEJ,MAAMO,SAASP,QAAQ,KAAK;QAC5BC,iBAAiBD,QAAQ,MAAM;IACnC;AACJ"}

package/utils/scan.d.ts

@@ -0,0 +1,38 @@
+import type { ScanInput, ScanOutput } from "@webiny/aws-sdk/client-dynamodb/index.js";
+import type { Entity, ScanOptions, TableDef } from "../toolbox.js";
+import type { ExecuteWithRetryOptions } from "@webiny/utils";
+export type { ScanOptions, ScanInput, ScanOutput };
+export interface BaseScanParams {
+    options?: ScanOptions;
+    params?: Partial<ScanInput>;
+}
+export interface ScanWithTable extends BaseScanParams {
+    table: TableDef;
+    entity?: never;
+}
+export interface ScanWithEntity extends BaseScanParams {
+    entity: Entity;
+    table?: never;
+}
+export type ScanParams = ScanWithTable | ScanWithEntity;
+export interface ScanResponse<T = any> {
+    items: T[];
+    count?: number;
+    scannedCount?: number;
+    lastEvaluatedKey?: ScanOutput["LastEvaluatedKey"];
+    next?: () => Promise<ScanResponse<T>>;
+    requestId: string;
+    error: any;
+}
+export type ScanDbItem<T> = T & {
+    PK: string;
+    SK: string;
+    GSI1_PK: string;
+    GSI1_SK: string;
+    TYPE: string;
+};
+export declare const scan: <T>(params: ScanParams) => Promise<ScanResponse<T>>;
+interface ScanWithCallbackOptions {
+    retry?: true | ExecuteWithRetryOptions;
+}
+export declare const scanWithCallback: <T>(params: ScanParams, callback: (result: ScanResponse<ScanDbItem<T>>) => Promise<void | boolean>, options?: ScanWithCallbackOptions) => Promise<void>;

package/utils/scan.js

@@ -0,0 +1,56 @@
+import { executeWithRetry } from "@webiny/utils";
+const createNext = (result)=>{
+    if (!result?.LastEvaluatedKey || !result.next) return;
+    return async ()=>{
+        const response = await result.next();
+        return convertResult(response);
+    };
+};
+const convertResult = (result)=>({
+        items: result.Items || [],
+        count: result.Count,
+        scannedCount: result.ScannedCount,
+        lastEvaluatedKey: result.LastEvaluatedKey || void 0,
+        next: createNext(result),
+        error: result.error,
+        requestId: result.$response?.requestId || ""
+    });
+const scan = async (params)=>{
+    const { options } = params;
+    const table = params.table ? params.table : params.entity.table;
+    if (!table) throw new Error(`Missing table for scan: ${JSON.stringify(options)}`);
+    const result = await table.scan({
+        ...options,
+        execute: true
+    }, params.params);
+    return convertResult(result);
+};
+const scanWithCallback = async (params, callback, options)=>{
+    const usingRetry = Boolean(options?.retry);
+    const retryOptions = options?.retry === true ? {} : options?.retry;
+    const executeScan = ()=>scan(params);
+    const getInitialResult = ()=>{
+        if (usingRetry) return executeWithRetry(executeScan, retryOptions);
+        return executeScan();
+    };
+    let result = await getInitialResult();
+    if (!result.items?.length && !result.lastEvaluatedKey) return;
+    const callbackResult = await callback(result);
+    const mustBreak = false === callbackResult;
+    if (mustBreak) return;
+    while(result.next){
+        const executeNext = ()=>result.next();
+        const getNextResult = ()=>{
+            if (usingRetry) return executeWithRetry(executeNext, retryOptions);
+            return executeNext();
+        };
+        result = await getNextResult();
+        const callbackResult = await callback(result);
+        const mustBreak = false === callbackResult;
+        if (mustBreak) break;
+        if (!result.next) return;
+    }
+};
+export { scan, scanWithCallback };
+
+//# sourceMappingURL=scan.js.map

package/utils/scan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils/scan.js","sources":["../../src/utils/scan.ts"],"sourcesContent":["import type { ScanInput, ScanOutput } from \"@webiny/aws-sdk/client-dynamodb/index.js\";\nimport type { Entity, ScanOptions, TableDef } from \"~/toolbox.js\";\nimport type { ExecuteWithRetryOptions } from \"@webiny/utils\";\nimport { executeWithRetry } from \"@webiny/utils\";\n\nexport type { ScanOptions, ScanInput, ScanOutput };\n\nexport interface BaseScanParams {\n    options?: ScanOptions;\n    params?: Partial<ScanInput>;\n}\n\nexport interface ScanWithTable extends BaseScanParams {\n    table: TableDef;\n    entity?: never;\n}\n\nexport interface ScanWithEntity extends BaseScanParams {\n    entity: Entity;\n    table?: never;\n}\n\nexport type ScanParams = ScanWithTable | ScanWithEntity;\n\nexport interface ScanResponse<T = any> {\n    items: T[];\n    count?: number;\n    scannedCount?: number;\n    lastEvaluatedKey?: ScanOutput[\"LastEvaluatedKey\"];\n    next?: () => Promise<ScanResponse<T>>;\n    requestId: string;\n    error: any;\n}\n\ninterface DdbScanResult<T> {\n    Items?: T[];\n    Count?: number;\n    ScannedCount?: number;\n    LastEvaluatedKey?: ScanOutput[\"LastEvaluatedKey\"];\n    next?: () => Promise<DdbScanResult<T>>;\n    error?: any;\n    $response?: {\n        requestId: string;\n    };\n}\n\ntype NextCb<T> = () => Promise<ScanResponse<T>>;\n\nconst createNext = <T>(result: DdbScanResult<T>): NextCb<T> | undefined => {\n    if (!result?.LastEvaluatedKey || !result.next) {\n        return undefined;\n    }\n    return async () => {\n        const response = await result!.next!();\n        return convertResult(response);\n    };\n};\n\nconst convertResult = <T>(result: DdbScanResult<T>): ScanResponse<T> => {\n    return {\n        items: result.Items || [],\n        count: result.Count,\n        scannedCount: result.ScannedCount,\n        lastEvaluatedKey: result.LastEvaluatedKey || undefined,\n        next: createNext<T>(result),\n        error: result.error,\n        requestId: result.$response?.requestId || \"\"\n    };\n};\n\nexport type ScanDbItem<T> = T & {\n    PK: string;\n    SK: string;\n    GSI1_PK: string;\n    GSI1_SK: string;\n    TYPE: string;\n};\n\nexport const scan = async <T>(params: ScanParams): Promise<ScanResponse<T>> => {\n    const { options } = params;\n\n    const table = params.table ? params.table : params.entity.table;\n    if (!table) {\n        throw new Error(`Missing table for scan: ${JSON.stringify(options)}`);\n    }\n\n    const result = await table.scan(\n        {\n            ...options,\n            execute: true\n        },\n        params.params\n    );\n\n    return convertResult(result) as ScanResponse<T>;\n};\n\ninterface ScanWithCallbackOptions {\n    retry?: true | ExecuteWithRetryOptions;\n}\n\nexport const scanWithCallback = async <T>(\n    params: ScanParams,\n    callback: (result: ScanResponse<ScanDbItem<T>>) => Promise<void | boolean>,\n    options?: ScanWithCallbackOptions\n): Promise<void> => {\n    // For backwards compatibility, we still allow for executing the scan without retries.\n    const usingRetry = Boolean(options?.retry);\n    const retryOptions = options?.retry === true ? {} : options?.retry;\n\n    const executeScan = () => scan<ScanDbItem<T>>(params);\n    const getInitialResult = () => {\n        if (usingRetry) {\n            return executeWithRetry(executeScan, retryOptions);\n        }\n        return executeScan();\n    };\n\n    let result = await getInitialResult();\n\n    if (!result.items?.length && !result.lastEvaluatedKey) {\n        return;\n    }\n\n    // If the result of the callback was `false`, that means the\n    // user's intention was to stop further table scanning.\n    const callbackResult = await callback(result);\n    const mustBreak = callbackResult === false;\n    if (mustBreak) {\n        return;\n    }\n\n    while (result.next) {\n        const executeNext = () => result.next!();\n        const getNextResult = () => {\n            if (usingRetry) {\n                return executeWithRetry(executeNext, retryOptions);\n            }\n            return executeNext();\n        };\n\n        result = await getNextResult();\n\n        // If the result of the callback was `false`, that means the\n        // user's intention was to stop further table scanning.\n        const callbackResult = await callback(result);\n        const mustBreak = callbackResult === false;\n        if (mustBreak) {\n            break;\n        }\n\n        if (!result.next) {\n            return;\n        }\n    }\n};\n"],"names":["createNext","result","response","convertResult","undefined","scan","params","options","table","Error","JSON","scanWithCallback","callback","usingRetry","Boolean","retryOptions","executeScan","getInitialResult","executeWithRetry","callbackResult","mustBreak","executeNext","getNextResult"],"mappings":";AAgDA,MAAMA,aAAa,CAAIC;IACnB,IAAI,CAACA,QAAQ,oBAAoB,CAACA,OAAO,IAAI,EACzC;IAEJ,OAAO;QACH,MAAMC,WAAW,MAAMD,OAAQ,IAAI;QACnC,OAAOE,cAAcD;IACzB;AACJ;AAEA,MAAMC,gBAAgB,CAAIF,SACf;QACH,OAAOA,OAAO,KAAK,IAAI,EAAE;QACzB,OAAOA,OAAO,KAAK;QACnB,cAAcA,OAAO,YAAY;QACjC,kBAAkBA,OAAO,gBAAgB,IAAIG;QAC7C,MAAMJ,WAAcC;QACpB,OAAOA,OAAO,KAAK;QACnB,WAAWA,OAAO,SAAS,EAAE,aAAa;IAC9C;AAWG,MAAMI,OAAO,OAAUC;IAC1B,MAAM,EAAEC,OAAO,EAAE,GAAGD;IAEpB,MAAME,QAAQF,OAAO,KAAK,GAAGA,OAAO,KAAK,GAAGA,OAAO,MAAM,CAAC,KAAK;IAC/D,IAAI,CAACE,OACD,MAAM,IAAIC,MAAM,CAAC,wBAAwB,EAAEC,KAAK,SAAS,CAACH,UAAU;IAGxE,MAAMN,SAAS,MAAMO,MAAM,IAAI,CAC3B;QACI,GAAGD,OAAO;QACV,SAAS;IACb,GACAD,OAAO,MAAM;IAGjB,OAAOH,cAAcF;AACzB;AAMO,MAAMU,mBAAmB,OAC5BL,QACAM,UACAL;IAGA,MAAMM,aAAaC,QAAQP,SAAS;IACpC,MAAMQ,eAAeR,SAAS,UAAU,OAAO,CAAC,IAAIA,SAAS;IAE7D,MAAMS,cAAc,IAAMX,KAAoBC;IAC9C,MAAMW,mBAAmB;QACrB,IAAIJ,YACA,OAAOK,iBAAiBF,aAAaD;QAEzC,OAAOC;IACX;IAEA,IAAIf,SAAS,MAAMgB;IAEnB,IAAI,CAAChB,OAAO,KAAK,EAAE,UAAU,CAACA,OAAO,gBAAgB,EACjD;IAKJ,MAAMkB,iBAAiB,MAAMP,SAASX;IACtC,MAAMmB,YAAYD,AAAmB,UAAnBA;IAClB,IAAIC,WACA;IAGJ,MAAOnB,OAAO,IAAI,CAAE;QAChB,MAAMoB,cAAc,IAAMpB,OAAO,IAAI;QACrC,MAAMqB,gBAAgB;YAClB,IAAIT,YACA,OAAOK,iBAAiBG,aAAaN;YAEzC,OAAOM;QACX;QAEApB,SAAS,MAAMqB;QAIf,MAAMH,iBAAiB,MAAMP,SAASX;QACtC,MAAMmB,YAAYD,AAAmB,UAAnBA;QAClB,IAAIC,WACA;QAGJ,IAAI,CAACnB,OAAO,IAAI,EACZ;IAER;AACJ"}

package/utils/sort.d.ts

@@ -1,4 +1,4 @@
-import { FieldPlugin } from "../plugins/definitions/FieldPlugin";
+import type { FieldPlugin } from "../plugins/definitions/FieldPlugin.js";
 interface Params<T> {
     /**
      * The items we are sorting.

package/utils/sort.js

@@ -1,91 +1,45 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.sortItems = sortItems;
-
-var _orderBy = _interopRequireDefault(require("lodash/orderBy"));
-
-var _error = _interopRequireDefault(require("@webiny/error"));
-
-const extractSort = (sortBy, fields) => {
-  const result = sortBy.split("_");
-
-  if (result.length !== 2) {
-    throw new _error.default("Problem in determining the sorting for the entry items.", "SORT_ERROR", {
-      sortBy
+import orderBy from "lodash/orderBy.js";
+import error from "@webiny/error";
+const extractSort = (sortBy, fields)=>{
+    const result = sortBy.split("_");
+    if (2 !== result.length) throw new error("Problem in determining the sorting for the entry items.", "SORT_ERROR", {
+        sortBy
     });
-  }
-
-  const [field, order] = result;
-
-  if (!field) {
-    throw new _error.default("Sorting field does not exist.", "SORTING_FIELD_ERROR", {
-      field,
-      order,
-      fields
+    const [field, order] = result;
+    if (!field) throw new error("Sorting field does not exist.", "SORTING_FIELD_ERROR", {
+        field,
+        order,
+        fields
     });
-  }
-
-  const fieldPlugin = fields.find(f => f.getField() === field);
-  const isSortable = fieldPlugin ? fieldPlugin.isSortable() : true;
-
-  if (isSortable === false) {
-    throw new _error.default(`Cannot sort by given field: "${field}".`, "UNSUPPORTED_SORT_ERROR", {
-      fields,
-      field
+    const fieldPlugin = fields.find((f)=>f.getField() === field);
+    const isSortable = fieldPlugin ? fieldPlugin.isSortable() : true;
+    if (false === isSortable) throw new error(`Cannot sort by given field: "${field}".`, "UNSUPPORTED_SORT_ERROR", {
+        fields,
+        field
     });
-  }
-
-  return {
-    field,
-    reverse: order.toUpperCase() === "DESC"
-  };
+    return {
+        field,
+        reverse: "DESC" === order.toUpperCase()
+    };
 };
-
 function sortItems(params) {
-  const {
-    items,
-    sort: initialSort = [],
-    fields = []
-  } = params;
-  /**
-   * Skip sorting if nothing was passed to sort by or nothing to sort.
-   */
-
-  if (items.length <= 1 || Array.isArray(initialSort) === false || initialSort.length === 0) {
-    return items;
-  }
-
-  const info = {
-    sorters: [],
-    orders: []
-  };
-
-  for (const sort of initialSort) {
-    /**
-     * Possibly empty array item was passed.
-     */
-    if (!sort) {
-      continue;
+    const { items, sort: initialSort = [], fields = [] } = params;
+    if (items.length <= 1 || false === Array.isArray(initialSort) || 0 === initialSort.length) return items;
+    const info = {
+        sorters: [],
+        orders: []
+    };
+    for (const sort of initialSort){
+        if (!sort) continue;
+        const { field, reverse } = extractSort(sort, fields);
+        const fieldPlugin = fields.find((f)=>f.getField() === field);
+        const path = fieldPlugin ? fieldPlugin.getPath() : field;
+        info.sorters.push(path);
+        info.orders.push(true === reverse ? "desc" : "asc");
     }
+    if (0 === info.sorters.length) return items;
+    return orderBy(items, info.sorters, info.orders);
+}
+export { sortItems };
 
-    const {
-      field,
-      reverse
-    } = extractSort(sort, fields);
-    const fieldPlugin = fields.find(f => f.getField() === field);
-    const path = fieldPlugin ? fieldPlugin.getPath() : field;
-    info.sorters.push(path);
-    info.orders.push(reverse === true ? "desc" : "asc");
-  }
-
-  if (info.sorters.length === 0) {
-    return items;
-  }
-
-  return (0, _orderBy.default)(items, info.sorters, info.orders);
-}
+//# sourceMappingURL=sort.js.map

package/utils/sort.js.map

@@ -1 +1 @@
-{"version":3,"names":["extractSort","sortBy","fields","result","split","length","WebinyError","field","order","fieldPlugin","find","f","getField","isSortable","reverse","toUpperCase","sortItems","params","items","sort","initialSort","Array","isArray","info","sorters","orders","path","getPath","push","lodashOrderBy"],"sources":["sort.ts"],"sourcesContent":["import lodashOrderBy from \"lodash/orderBy\";\nimport WebinyError from \"@webiny/error\";\nimport { FieldPlugin } from \"~/plugins/definitions/FieldPlugin\";\n\ninterface Info {\n    sorters: string[];\n    orders: (boolean | \"asc\" | \"desc\")[];\n}\n\ninterface Response {\n    reverse: boolean;\n    field: string;\n}\n\nconst extractSort = (sortBy: string, fields: FieldPlugin[]): Response => {\n    const result = sortBy.split(\"_\");\n    if (result.length !== 2) {\n        throw new WebinyError(\n            \"Problem in determining the sorting for the entry items.\",\n            \"SORT_ERROR\",\n            {\n                sortBy\n            }\n        );\n    }\n    const [field, order] = result;\n\n    if (!field) {\n        throw new WebinyError(\"Sorting field does not exist.\", \"SORTING_FIELD_ERROR\", {\n            field,\n            order,\n            fields\n        });\n    }\n    const fieldPlugin = fields.find(f => f.getField() === field);\n    const isSortable = fieldPlugin ? fieldPlugin.isSortable() : true;\n    if (isSortable === false) {\n        throw new WebinyError(`Cannot sort by given field: \"${field}\".`, \"UNSUPPORTED_SORT_ERROR\", {\n            fields,\n            field\n        });\n    }\n\n    return {\n        field,\n        reverse: order.toUpperCase() === \"DESC\"\n    };\n};\n\ninterface Params<T> {\n    /**\n     * The items we are sorting.\n     */\n    items: T[];\n    /**\n     * Sort options. For example: [\"id_ASC\"]\n     */\n    sort?: string[];\n    /**\n     * Fields we can sort by.\n     */\n    fields?: FieldPlugin[];\n}\n\nexport function sortItems<T = any>(params: Params<T>): T[] {\n    const { items, sort: initialSort = [], fields = [] } = params;\n    /**\n     * Skip sorting if nothing was passed to sort by or nothing to sort.\n     */\n    if (items.length <= 1 || Array.isArray(initialSort) === false || initialSort.length === 0) {\n        return items;\n    }\n\n    const info: Info = {\n        sorters: [],\n        orders: []\n    };\n\n    for (const sort of initialSort) {\n        /**\n         * Possibly empty array item was passed.\n         */\n        if (!sort) {\n            continue;\n        }\n        const { field, reverse } = extractSort(sort, fields);\n        const fieldPlugin = fields.find(f => f.getField() === field);\n        const path = fieldPlugin ? fieldPlugin.getPath() : field;\n\n        info.sorters.push(path);\n        info.orders.push(reverse === true ? \"desc\" : \"asc\");\n    }\n\n    if (info.sorters.length === 0) {\n        return items;\n    }\n\n    return lodashOrderBy(items, info.sorters, info.orders);\n}\n"],"mappings":";;;;;;;;;AAAA;;AACA;;AAaA,MAAMA,WAAW,GAAG,CAACC,MAAD,EAAiBC,MAAjB,KAAqD;EACrE,MAAMC,MAAM,GAAGF,MAAM,CAACG,KAAP,CAAa,GAAb,CAAf;;EACA,IAAID,MAAM,CAACE,MAAP,KAAkB,CAAtB,EAAyB;IACrB,MAAM,IAAIC,cAAJ,CACF,yDADE,EAEF,YAFE,EAGF;MACIL;IADJ,CAHE,CAAN;EAOH;;EACD,MAAM,CAACM,KAAD,EAAQC,KAAR,IAAiBL,MAAvB;;EAEA,IAAI,CAACI,KAAL,EAAY;IACR,MAAM,IAAID,cAAJ,CAAgB,+BAAhB,EAAiD,qBAAjD,EAAwE;MAC1EC,KAD0E;MAE1EC,KAF0E;MAG1EN;IAH0E,CAAxE,CAAN;EAKH;;EACD,MAAMO,WAAW,GAAGP,MAAM,CAACQ,IAAP,CAAYC,CAAC,IAAIA,CAAC,CAACC,QAAF,OAAiBL,KAAlC,CAApB;EACA,MAAMM,UAAU,GAAGJ,WAAW,GAAGA,WAAW,CAACI,UAAZ,EAAH,GAA8B,IAA5D;;EACA,IAAIA,UAAU,KAAK,KAAnB,EAA0B;IACtB,MAAM,IAAIP,cAAJ,CAAiB,gCAA+BC,KAAM,IAAtD,EAA2D,wBAA3D,EAAqF;MACvFL,MADuF;MAEvFK;IAFuF,CAArF,CAAN;EAIH;;EAED,OAAO;IACHA,KADG;IAEHO,OAAO,EAAEN,KAAK,CAACO,WAAN,OAAwB;EAF9B,CAAP;AAIH,CAjCD;;AAkDO,SAASC,SAAT,CAA4BC,MAA5B,EAAoD;EACvD,MAAM;IAAEC,KAAF;IAASC,IAAI,EAAEC,WAAW,GAAG,EAA7B;IAAiClB,MAAM,GAAG;EAA1C,IAAiDe,MAAvD;EACA;AACJ;AACA;;EACI,IAAIC,KAAK,CAACb,MAAN,IAAgB,CAAhB,IAAqBgB,KAAK,CAACC,OAAN,CAAcF,WAAd,MAA+B,KAApD,IAA6DA,WAAW,CAACf,MAAZ,KAAuB,CAAxF,EAA2F;IACvF,OAAOa,KAAP;EACH;;EAED,MAAMK,IAAU,GAAG;IACfC,OAAO,EAAE,EADM;IAEfC,MAAM,EAAE;EAFO,CAAnB;;EAKA,KAAK,MAAMN,IAAX,IAAmBC,WAAnB,EAAgC;IAC5B;AACR;AACA;IACQ,IAAI,CAACD,IAAL,EAAW;MACP;IACH;;IACD,MAAM;MAAEZ,KAAF;MAASO;IAAT,IAAqBd,WAAW,CAACmB,IAAD,EAAOjB,MAAP,CAAtC;IACA,MAAMO,WAAW,GAAGP,MAAM,CAACQ,IAAP,CAAYC,CAAC,IAAIA,CAAC,CAACC,QAAF,OAAiBL,KAAlC,CAApB;IACA,MAAMmB,IAAI,GAAGjB,WAAW,GAAGA,WAAW,CAACkB,OAAZ,EAAH,GAA2BpB,KAAnD;IAEAgB,IAAI,CAACC,OAAL,CAAaI,IAAb,CAAkBF,IAAlB;IACAH,IAAI,CAACE,MAAL,CAAYG,IAAZ,CAAiBd,OAAO,KAAK,IAAZ,GAAmB,MAAnB,GAA4B,KAA7C;EACH;;EAED,IAAIS,IAAI,CAACC,OAAL,CAAanB,MAAb,KAAwB,CAA5B,EAA+B;IAC3B,OAAOa,KAAP;EACH;;EAED,OAAO,IAAAW,gBAAA,EAAcX,KAAd,EAAqBK,IAAI,CAACC,OAA1B,EAAmCD,IAAI,CAACE,MAAxC,CAAP;AACH"}
+{"version":3,"file":"utils/sort.js","sources":["../../src/utils/sort.ts"],"sourcesContent":["import lodashOrderBy from \"lodash/orderBy.js\";\nimport WebinyError from \"@webiny/error\";\nimport type { FieldPlugin } from \"~/plugins/definitions/FieldPlugin.js\";\n\ninterface Info {\n    sorters: string[];\n    orders: (boolean | \"asc\" | \"desc\")[];\n}\n\ninterface Response {\n    reverse: boolean;\n    field: string;\n}\n\nconst extractSort = (sortBy: string, fields: FieldPlugin[]): Response => {\n    const result = sortBy.split(\"_\");\n    if (result.length !== 2) {\n        throw new WebinyError(\n            \"Problem in determining the sorting for the entry items.\",\n            \"SORT_ERROR\",\n            {\n                sortBy\n            }\n        );\n    }\n    const [field, order] = result;\n\n    if (!field) {\n        throw new WebinyError(\"Sorting field does not exist.\", \"SORTING_FIELD_ERROR\", {\n            field,\n            order,\n            fields\n        });\n    }\n    const fieldPlugin = fields.find(f => f.getField() === field);\n    const isSortable = fieldPlugin ? fieldPlugin.isSortable() : true;\n    if (isSortable === false) {\n        throw new WebinyError(`Cannot sort by given field: \"${field}\".`, \"UNSUPPORTED_SORT_ERROR\", {\n            fields,\n            field\n        });\n    }\n\n    return {\n        field,\n        reverse: order.toUpperCase() === \"DESC\"\n    };\n};\n\ninterface Params<T> {\n    /**\n     * The items we are sorting.\n     */\n    items: T[];\n    /**\n     * Sort options. For example: [\"id_ASC\"]\n     */\n    sort?: string[];\n    /**\n     * Fields we can sort by.\n     */\n    fields?: FieldPlugin[];\n}\n\nexport function sortItems<T = any>(params: Params<T>): T[] {\n    const { items, sort: initialSort = [], fields = [] } = params;\n    /**\n     * Skip sorting if nothing was passed to sort by or nothing to sort.\n     */\n    if (items.length <= 1 || Array.isArray(initialSort) === false || initialSort.length === 0) {\n        return items;\n    }\n\n    const info: Info = {\n        sorters: [],\n        orders: []\n    };\n\n    for (const sort of initialSort) {\n        /**\n         * Possibly empty array item was passed.\n         */\n        if (!sort) {\n            continue;\n        }\n        const { field, reverse } = extractSort(sort, fields);\n        const fieldPlugin = fields.find(f => f.getField() === field);\n        const path = fieldPlugin ? fieldPlugin.getPath() : field;\n\n        info.sorters.push(path);\n        info.orders.push(reverse === true ? \"desc\" : \"asc\");\n    }\n\n    if (info.sorters.length === 0) {\n        return items;\n    }\n\n    return lodashOrderBy(items, info.sorters, info.orders);\n}\n"],"names":["extractSort","sortBy","fields","result","WebinyError","field","order","fieldPlugin","f","isSortable","sortItems","params","items","initialSort","Array","info","sort","reverse","path","lodashOrderBy"],"mappings":";;AAcA,MAAMA,cAAc,CAACC,QAAgBC;IACjC,MAAMC,SAASF,OAAO,KAAK,CAAC;IAC5B,IAAIE,AAAkB,MAAlBA,OAAO,MAAM,EACb,MAAM,IAAIC,MACN,2DACA,cACA;QACIH;IACJ;IAGR,MAAM,CAACI,OAAOC,MAAM,GAAGH;IAEvB,IAAI,CAACE,OACD,MAAM,IAAID,MAAY,iCAAiC,uBAAuB;QAC1EC;QACAC;QACAJ;IACJ;IAEJ,MAAMK,cAAcL,OAAO,IAAI,CAACM,CAAAA,IAAKA,EAAE,QAAQ,OAAOH;IACtD,MAAMI,aAAaF,cAAcA,YAAY,UAAU,KAAK;IAC5D,IAAIE,AAAe,UAAfA,YACA,MAAM,IAAIL,MAAY,CAAC,6BAA6B,EAAEC,MAAM,EAAE,CAAC,EAAE,0BAA0B;QACvFH;QACAG;IACJ;IAGJ,OAAO;QACHA;QACA,SAASC,AAAwB,WAAxBA,MAAM,WAAW;IAC9B;AACJ;AAiBO,SAASI,UAAmBC,MAAiB;IAChD,MAAM,EAAEC,KAAK,EAAE,MAAMC,cAAc,EAAE,EAAEX,SAAS,EAAE,EAAE,GAAGS;IAIvD,IAAIC,MAAM,MAAM,IAAI,KAAKE,AAA+B,UAA/BA,MAAM,OAAO,CAACD,gBAA0BA,AAAuB,MAAvBA,YAAY,MAAM,EAC/E,OAAOD;IAGX,MAAMG,OAAa;QACf,SAAS,EAAE;QACX,QAAQ,EAAE;IACd;IAEA,KAAK,MAAMC,QAAQH,YAAa;QAI5B,IAAI,CAACG,MACD;QAEJ,MAAM,EAAEX,KAAK,EAAEY,OAAO,EAAE,GAAGjB,YAAYgB,MAAMd;QAC7C,MAAMK,cAAcL,OAAO,IAAI,CAACM,CAAAA,IAAKA,EAAE,QAAQ,OAAOH;QACtD,MAAMa,OAAOX,cAAcA,YAAY,OAAO,KAAKF;QAEnDU,KAAK,OAAO,CAAC,IAAI,CAACG;QAClBH,KAAK,MAAM,CAAC,IAAI,CAACE,AAAY,SAAZA,UAAmB,SAAS;IACjD;IAEA,IAAIF,AAAwB,MAAxBA,KAAK,OAAO,CAAC,MAAM,EACnB,OAAOH;IAGX,OAAOO,QAAcP,OAAOG,KAAK,OAAO,EAAEA,KAAK,MAAM;AACzD"}

package/utils/table/Table.d.ts

@@ -0,0 +1,10 @@
+import type { TableConstructor } from "../../toolbox.js";
+import { Table as BaseTable } from "../../toolbox.js";
+import type { ITable, ITableReadBatch, ITableScanParams, ITableScanResponse, ITableWriteBatch } from "./types.js";
+export declare class Table<Name extends string = string, PartitionKey extends string = string, SortKey extends string = string> implements ITable<Name, PartitionKey, SortKey> {
+    readonly table: BaseTable<Name, PartitionKey, SortKey>;
+    constructor(params: TableConstructor<Name, PartitionKey, SortKey>);
+    createWriter(): ITableWriteBatch;
+    createReader(): ITableReadBatch;
+    scan<T>(params: ITableScanParams): Promise<ITableScanResponse<T>>;
+}

package/utils/table/Table.js

@@ -0,0 +1,28 @@
+import { Table } from "../../toolbox.js";
+import { createTableWriteBatch } from "./TableWriteBatch.js";
+import { createTableReadBatch } from "./TableReadBatch.js";
+import { scan } from "../scan.js";
+class Table_Table {
+    constructor(params){
+        this.table = new Table(params);
+    }
+    createWriter() {
+        return createTableWriteBatch({
+            table: this.table
+        });
+    }
+    createReader() {
+        return createTableReadBatch({
+            table: this.table
+        });
+    }
+    async scan(params) {
+        return scan({
+            ...params,
+            table: this.table
+        });
+    }
+}
+export { Table_Table as Table };
+
+//# sourceMappingURL=Table.js.map