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

package/toolbox.d.ts

@@ -0,0 +1,60 @@
+export { Entity, Table } from "dynamodb-toolbox";
+import { Entity, Table } from "dynamodb-toolbox";
+export type ScanOptions = NonNullable<Parameters<Entity["scan"]>[0]>;
+export type DynamoDBTypes = "string" | "boolean" | "number" | "bigint" | "list" | "map" | "binary" | "set";
+type Key = string | number | symbol;
+export type TableDef = Table<string, Key, Key | null>;
+export type TableConstructor<A extends string, B extends Key, C extends Key> = ConstructorParameters<typeof Table<A, B, C>>[0];
+export type Readonly<T> = T extends ((...args: any[]) => any) | undefined ? T : T extends object ? {
+    readonly [P in keyof T]: Readonly<T[P]>;
+} : T;
+export type AttributeDefinition = DynamoDBTypes | Partial<{
+    type: DynamoDBTypes;
+    coerce: boolean;
+    default: unknown;
+    dependsOn: string | string[];
+    required: boolean | "always";
+    hidden: boolean;
+    prefix: string;
+    suffix: string;
+    delimiter: string;
+    map: string;
+    alias: string;
+    onlyMap: boolean;
+    partitionKey: boolean;
+    sortKey: boolean;
+    [key: string]: unknown;
+}> | [string, number] | [string, number, string] | [string, number, Record<string, unknown>];
+export type AttributeDefinitions = Record<PropertyKey, AttributeDefinition>;
+export interface EntityConstructor<T extends Readonly<AttributeDefinitions> = Readonly<AttributeDefinitions>> {
+    name: string;
+    attributes: T;
+    table?: TableDef;
+    timestamps?: boolean;
+    createdAlias?: string;
+    modifiedAlias?: string;
+    typeAlias?: string;
+    typeHidden?: boolean;
+    autoExecute?: boolean;
+    autoParse?: boolean;
+}
+export interface EntityQueryOptions {
+    index?: string;
+    limit?: number;
+    reverse?: boolean;
+    consistent?: boolean;
+    capacity?: "indexes" | "total" | "none";
+    select?: "all_attributes" | "all_projected_attributes" | "count" | "specific_attributes";
+    eq?: string | number;
+    lt?: string | number;
+    lte?: string | number;
+    gt?: string | number;
+    gte?: string | number;
+    between?: [string, string] | [number, number] | [bigint, bigint];
+    beginsWith?: string;
+    startKey?: Record<string, unknown>;
+    filters?: Record<string, unknown>;
+    attributes?: string[];
+    execute?: boolean;
+    parse?: boolean;
+}

package/toolbox.js

@@ -0,0 +1 @@
+export { Entity, Table } from "dynamodb-toolbox";

package/types.d.ts

@@ -1,23 +1,3 @@
-export interface OperatorArgs {
-    expression: string;
-    attributeNames: Record<string, any>;
-    attributeValues: Record<string, any>;
-}
-interface CanProcessArgs {
-    key: string;
-    value: any;
-    args: OperatorArgs;
-}
-interface ProcessArgs {
-    key: string;
-    value: any;
-    args: OperatorArgs;
-    processStatement: any;
-}
-export interface Operator {
-    canProcess: ({ key }: CanProcessArgs) => boolean;
-    process: ({ key, value, args }: ProcessArgs) => void;
-}
 /**
  * We use this definition to search for a value in any given field that was passed.
  * It works as an "OR" condition.
@@ -53,6 +33,13 @@ export interface QueryKey {
     unique?: boolean;
     name: string;
 }
-export declare type QueryKeys = QueryKey[];
-export declare type QuerySort = Record<string, -1 | 1>;
-export {};
+export type QueryKeys = QueryKey[];
+export type QuerySort = Record<string, -1 | 1>;
+export type DbItem<TData extends Record<string, any> = Record<string, any>> = {
+    PK: string;
+    SK: string;
+    GSI1_PK: string;
+    GSI1_SK: string;
+    TYPE: string;
+    data: TData;
+};

package/types.js

@@ -1,5 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});

package/utils/batch/batchRead.d.ts

@@ -0,0 +1,15 @@
+import type { TableDef } from "../../toolbox.js";
+import type { GenericRecord } from "@webiny/api/types.js";
+export interface BatchReadItem {
+    Table?: TableDef;
+    Key: any;
+}
+export interface BatchReadParams {
+    table?: TableDef;
+    items: BatchReadItem[];
+}
+/**
+ * This helper function is meant to be used to batch read from one table.
+ * It will fetch all results, as there is a next() method call built in.
+ */
+export declare const batchReadAll: <T = GenericRecord>(params: BatchReadParams, maxChunk?: number) => Promise<T[]>;

package/utils/batch/batchRead.js

@@ -0,0 +1,45 @@
+import chunk from "lodash/chunk.js";
+import error from "@webiny/error";
+const MAX_BATCH_ITEMS = 100;
+const flatten = (responses)=>{
+    const entries = [];
+    const values = Object.values(responses);
+    for (const items of values)entries.push(...items);
+    return entries;
+};
+const batchReadAllChunk = async (params)=>{
+    const { table, items } = params;
+    const records = [];
+    if (!table) return records;
+    const result = await table.batchGet(items);
+    if (!result || !result.Responses) return records;
+    records.push(...flatten(result.Responses));
+    if (!result.next || "function" != typeof result.next) return records;
+    let previous = result;
+    while("function" == typeof previous.next){
+        const nextResult = await previous.next();
+        if (!nextResult) break;
+        records.push(...flatten(nextResult.Responses));
+        previous = nextResult;
+    }
+    return records;
+};
+const batchReadAll = async (params, maxChunk = MAX_BATCH_ITEMS)=>{
+    if (0 === params.items.length) return [];
+    if (maxChunk > MAX_BATCH_ITEMS) throw new error(`Cannot set to load more than ${MAX_BATCH_ITEMS} items from the DynamoDB at once.`, "DYNAMODB_MAX_BATCH_GET_LIMIT_ERROR", {
+        maxChunk
+    });
+    const records = [];
+    const chunkItemsList = chunk(params.items, maxChunk);
+    for (const chunkItems of chunkItemsList){
+        const results = await batchReadAllChunk({
+            table: params.table,
+            items: chunkItems
+        });
+        records.push(...results);
+    }
+    return records;
+};
+export { batchReadAll };
+
+//# sourceMappingURL=batchRead.js.map

package/utils/batch/batchRead.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils/batch/batchRead.js","sources":["../../../src/utils/batch/batchRead.ts"],"sourcesContent":["import lodashChunk from \"lodash/chunk.js\";\nimport WebinyError from \"@webiny/error\";\nimport type { TableDef } from \"~/toolbox.js\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\n\nexport interface BatchReadItem {\n    Table?: TableDef;\n    Key: any;\n}\nexport interface BatchReadParams {\n    table?: TableDef;\n    items: BatchReadItem[];\n}\n\nconst MAX_BATCH_ITEMS = 100;\n\nconst flatten = (responses: Record<string, any[]>): any[] => {\n    const entries = [];\n    const values = Object.values(responses);\n    for (const items of values) {\n        entries.push(...items);\n    }\n    return entries;\n};\n\ninterface BatchReadAllChunkParams {\n    table?: TableDef;\n    items: BatchReadItem[];\n}\nconst batchReadAllChunk = async <T = any>(params: BatchReadAllChunkParams): Promise<T[]> => {\n    const { table, items } = params;\n    const records: T[] = [];\n\n    if (!table) {\n        return records;\n    }\n\n    const result = await table.batchGet(items);\n    if (!result || !result.Responses) {\n        return records;\n    }\n    records.push(...flatten(result.Responses));\n    if (!result.next || typeof result.next !== \"function\") {\n        return records;\n    }\n    let previous = result;\n    while (typeof previous.next === \"function\") {\n        const nextResult = await previous.next();\n        if (!nextResult) {\n            return records;\n        }\n        records.push(...flatten(nextResult.Responses));\n        previous = nextResult;\n    }\n    return records;\n};\n/**\n * This helper function is meant to be used to batch read from one table.\n * It will fetch all results, as there is a next() method call built in.\n */\nexport const batchReadAll = async <T = GenericRecord>(\n    params: BatchReadParams,\n    maxChunk = MAX_BATCH_ITEMS\n): Promise<T[]> => {\n    if (params.items.length === 0) {\n        return [];\n    } else if (maxChunk > MAX_BATCH_ITEMS) {\n        throw new WebinyError(\n            `Cannot set to load more than ${MAX_BATCH_ITEMS} items from the DynamoDB at once.`,\n            \"DYNAMODB_MAX_BATCH_GET_LIMIT_ERROR\",\n            {\n                maxChunk\n            }\n        );\n    }\n\n    const records: T[] = [];\n\n    const chunkItemsList = lodashChunk(params.items, maxChunk);\n\n    for (const chunkItems of chunkItemsList) {\n        const results = await batchReadAllChunk<T>({\n            table: params.table,\n            items: chunkItems\n        });\n\n        records.push(...results);\n    }\n\n    return records;\n};\n"],"names":["MAX_BATCH_ITEMS","flatten","responses","entries","values","Object","items","batchReadAllChunk","params","table","records","result","previous","nextResult","batchReadAll","maxChunk","WebinyError","chunkItemsList","lodashChunk","chunkItems","results"],"mappings":";;AAcA,MAAMA,kBAAkB;AAExB,MAAMC,UAAU,CAACC;IACb,MAAMC,UAAU,EAAE;IAClB,MAAMC,SAASC,OAAO,MAAM,CAACH;IAC7B,KAAK,MAAMI,SAASF,OAChBD,QAAQ,IAAI,IAAIG;IAEpB,OAAOH;AACX;AAMA,MAAMI,oBAAoB,OAAgBC;IACtC,MAAM,EAAEC,KAAK,EAAEH,KAAK,EAAE,GAAGE;IACzB,MAAME,UAAe,EAAE;IAEvB,IAAI,CAACD,OACD,OAAOC;IAGX,MAAMC,SAAS,MAAMF,MAAM,QAAQ,CAACH;IACpC,IAAI,CAACK,UAAU,CAACA,OAAO,SAAS,EAC5B,OAAOD;IAEXA,QAAQ,IAAI,IAAIT,QAAQU,OAAO,SAAS;IACxC,IAAI,CAACA,OAAO,IAAI,IAAI,AAAuB,cAAvB,OAAOA,OAAO,IAAI,EAClC,OAAOD;IAEX,IAAIE,WAAWD;IACf,MAAO,AAAyB,cAAzB,OAAOC,SAAS,IAAI,CAAiB;QACxC,MAAMC,aAAa,MAAMD,SAAS,IAAI;QACtC,IAAI,CAACC,YACD;QAEJH,QAAQ,IAAI,IAAIT,QAAQY,WAAW,SAAS;QAC5CD,WAAWC;IACf;IACA,OAAOH;AACX;AAKO,MAAMI,eAAe,OACxBN,QACAO,WAAWf,eAAe;IAE1B,IAAIQ,AAAwB,MAAxBA,OAAO,KAAK,CAAC,MAAM,EACnB,OAAO,EAAE;IACN,IAAIO,WAAWf,iBAClB,MAAM,IAAIgB,MACN,CAAC,6BAA6B,EAAEhB,gBAAgB,iCAAiC,CAAC,EAClF,sCACA;QACIe;IACJ;IAIR,MAAML,UAAe,EAAE;IAEvB,MAAMO,iBAAiBC,MAAYV,OAAO,KAAK,EAAEO;IAEjD,KAAK,MAAMI,cAAcF,eAAgB;QACrC,MAAMG,UAAU,MAAMb,kBAAqB;YACvC,OAAOC,OAAO,KAAK;YACnB,OAAOW;QACX;QAEAT,QAAQ,IAAI,IAAIU;IACpB;IAEA,OAAOV;AACX"}

package/utils/batch/batchWrite.d.ts

@@ -0,0 +1,13 @@
+import type { TableDef } from "../../toolbox.js";
+import type { BatchWriteItem, BatchWriteResult } from "./types.js";
+export interface BatchWriteParams {
+    table: TableDef | undefined;
+    items: BatchWriteItem[];
+}
+/**
+ * Method is meant for batch writing to a single table.
+ * It expects already prepared items for writing.
+ * It can either delete or put items
+ * The method does not check items before actually sending them into the underlying library.
+ */
+export declare const batchWriteAll: (params: BatchWriteParams, maxChunk?: number) => Promise<BatchWriteResult>;

package/utils/batch/batchWrite.js

@@ -0,0 +1,39 @@
+import chunk from "lodash/chunk.js";
+const hasUnprocessedItems = (result)=>{
+    if ("function" != typeof result.next) return false;
+    const items = result.UnprocessedItems;
+    if (!items || "object" != typeof items) return false;
+    const keys = Object.keys(items);
+    return keys.some((key)=>{
+        const value = items[key];
+        if (!Array.isArray(value)) return false;
+        return value.some((val)=>val.PutRequest || val.DeleteRequest);
+    });
+};
+const retry = async (input, results)=>{
+    if (!hasUnprocessedItems(input)) return;
+    const result = await input.next();
+    await retry(result, results);
+};
+const batchWriteAll = async (params, maxChunk = 25)=>{
+    const { items: collection, table } = params;
+    if (table) {
+        if (0 === collection.length) return [];
+    } else {
+        console.log("No table provided.");
+        return [];
+    }
+    const chunkedItems = chunk(collection, maxChunk);
+    const results = [];
+    for (const items of chunkedItems){
+        const result = await table.batchWrite(items, {
+            execute: true
+        });
+        results.push(result);
+        await retry(result, results);
+    }
+    return results;
+};
+export { batchWriteAll };
+
+//# sourceMappingURL=batchWrite.js.map

package/utils/batch/batchWrite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils/batch/batchWrite.js","sources":["../../../src/utils/batch/batchWrite.ts"],"sourcesContent":["import lodashChunk from \"lodash/chunk.js\";\nimport type { TableDef } from \"~/toolbox.js\";\nimport type { BatchWriteItem, BatchWriteResponse, BatchWriteResult } from \"./types.js\";\n\nexport interface BatchWriteParams {\n    table: TableDef | undefined;\n    items: BatchWriteItem[];\n}\n\nconst hasUnprocessedItems = (result: BatchWriteResponse): boolean => {\n    if (typeof result.next !== \"function\") {\n        return false;\n    }\n    const items = result.UnprocessedItems;\n    if (!items || typeof items !== \"object\") {\n        return false;\n    }\n    const keys = Object.keys(items);\n    return keys.some(key => {\n        const value = items[key];\n        if (!Array.isArray(value)) {\n            return false;\n        }\n        return value.some(val => {\n            return val.PutRequest || val.DeleteRequest;\n        });\n    });\n};\n\nconst retry = async (input: BatchWriteResponse, results: BatchWriteResult): Promise<void> => {\n    if (!hasUnprocessedItems(input)) {\n        return;\n    }\n    const result = await input.next!();\n    await retry(result, results);\n};\n/**\n * Method is meant for batch writing to a single table.\n * It expects already prepared items for writing.\n * It can either delete or put items\n * The method does not check items before actually sending them into the underlying library.\n */\nexport const batchWriteAll = async (\n    params: BatchWriteParams,\n    maxChunk = 25\n): Promise<BatchWriteResult> => {\n    const { items: collection, table } = params;\n    if (!table) {\n        console.log(\"No table provided.\");\n        return [];\n    } else if (collection.length === 0) {\n        return [];\n    }\n\n    const chunkedItems: BatchWriteItem[][] = lodashChunk(collection, maxChunk);\n    const results: BatchWriteResult = [];\n    for (const items of chunkedItems) {\n        const result = (await table.batchWrite(items, {\n            execute: true\n        })) as BatchWriteResponse;\n        results.push(result);\n        await retry(result, results);\n    }\n    return results;\n};\n"],"names":["hasUnprocessedItems","result","items","keys","Object","key","value","Array","val","retry","input","results","batchWriteAll","params","maxChunk","collection","table","console","chunkedItems","lodashChunk"],"mappings":";AASA,MAAMA,sBAAsB,CAACC;IACzB,IAAI,AAAuB,cAAvB,OAAOA,OAAO,IAAI,EAClB,OAAO;IAEX,MAAMC,QAAQD,OAAO,gBAAgB;IACrC,IAAI,CAACC,SAAS,AAAiB,YAAjB,OAAOA,OACjB,OAAO;IAEX,MAAMC,OAAOC,OAAO,IAAI,CAACF;IACzB,OAAOC,KAAK,IAAI,CAACE,CAAAA;QACb,MAAMC,QAAQJ,KAAK,CAACG,IAAI;QACxB,IAAI,CAACE,MAAM,OAAO,CAACD,QACf,OAAO;QAEX,OAAOA,MAAM,IAAI,CAACE,CAAAA,MACPA,IAAI,UAAU,IAAIA,IAAI,aAAa;IAElD;AACJ;AAEA,MAAMC,QAAQ,OAAOC,OAA2BC;IAC5C,IAAI,CAACX,oBAAoBU,QACrB;IAEJ,MAAMT,SAAS,MAAMS,MAAM,IAAI;IAC/B,MAAMD,MAAMR,QAAQU;AACxB;AAOO,MAAMC,gBAAgB,OACzBC,QACAC,WAAW,EAAE;IAEb,MAAM,EAAE,OAAOC,UAAU,EAAEC,KAAK,EAAE,GAAGH;IACrC,IAAKG,OAGE;QAAA,IAAID,AAAsB,MAAtBA,WAAW,MAAM,EACxB,OAAO,EAAE;IACb,OALY;QACRE,QAAQ,GAAG,CAAC;QACZ,OAAO,EAAE;IACb;IAIA,MAAMC,eAAmCC,MAAYJ,YAAYD;IACjE,MAAMH,UAA4B,EAAE;IACpC,KAAK,MAAMT,SAASgB,aAAc;QAC9B,MAAMjB,SAAU,MAAMe,MAAM,UAAU,CAACd,OAAO;YAC1C,SAAS;QACb;QACAS,QAAQ,IAAI,CAACV;QACb,MAAMQ,MAAMR,QAAQU;IACxB;IACA,OAAOA;AACX"}

package/utils/batch/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./batchRead.js";
+export * from "./batchWrite.js";
+export * from "./types.js";

package/utils/batch/index.js

@@ -0,0 +1,3 @@
+export * from "./batchRead.js";
+export * from "./batchWrite.js";
+export * from "./types.js";

package/utils/batch/types.d.ts

@@ -0,0 +1,30 @@
+import type { WriteRequest } from "@webiny/aws-sdk/client-dynamodb/index.js";
+import type { GenericRecord } from "@webiny/api/types.js";
+export interface BatchWriteResponse {
+    next?: () => Promise<BatchWriteResponse>;
+    $metadata: {
+        httpStatusCode: number;
+        requestId: string;
+        attempts: number;
+        totalRetryDelay: number;
+    };
+    UnprocessedItems?: {
+        [table: string]: WriteRequest[];
+    };
+}
+export type BatchWriteResult = BatchWriteResponse[];
+export interface IDeleteBatchItem {
+    PK: string;
+    SK: string;
+}
+export type IPutBatchItem<T = GenericRecord> = {
+    PK: string;
+    SK: string;
+} & T;
+export interface BatchWriteItem {
+    [key: string]: WriteRequest;
+}
+export interface IReadBatchItem {
+    PK: string;
+    SK: string;
+}

package/utils/cleanup.d.ts

@@ -1,3 +1,3 @@
-import { Entity } from "dynamodb-toolbox";
-export declare function cleanupItem<T>(entity: Entity<any>, item?: (T & Record<string, any>) | null, removeAttributes?: string[]): T | null;
-export declare function cleanupItems<T>(entity: Entity<any>, items: (T & Record<string, any>)[], removeAttributes?: string[]): T[];
+import type { Entity } from "../toolbox.js";
+export declare function cleanupItem<T>(entity: Entity<any>, item?: T | null, removeAttributes?: string[]): T | null;
+export declare function cleanupItems<T>(entity: Entity<any>, items: T[], removeAttributes?: string[]): T[];

package/utils/cleanup.js

@@ -1,45 +1,40 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.cleanupItem = cleanupItem;
-exports.cleanupItems = cleanupItems;
-
-var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
-
-/**
- * The attributes defined by us or the dynamodb-toolbox library.
- * Add more attributes if necessary.
- */
-const attributesToRemove = ["PK", "SK", "created", "_ct", "modified", "_mt", "entity", "_et", "GSI1_PK", "GSI1_SK", "TYPE"];
-
+const attributesToRemove = [
+    "PK",
+    "SK",
+    "created",
+    "_ct",
+    "modified",
+    "_mt",
+    "entity",
+    "_et",
+    "GSI1_PK",
+    "GSI1_SK",
+    "GSI2_PK",
+    "GSI2_SK",
+    "GSI3_PK",
+    "GSI3_SK",
+    "GSI4_PK",
+    "GSI4_SK",
+    "GSI5_PK",
+    "GSI5_SK",
+    "GSI_TENANT",
+    "TYPE"
+];
 function cleanupItem(entity, item, removeAttributes = []) {
-  if (!item) {
-    return null;
-  }
-
-  const newItem = (0, _objectSpread2.default)({}, item);
-  const targets = attributesToRemove.concat(removeAttributes);
-  const attributes = entity.schema.attributes;
-
-  for (const key in item) {
-    if (item.hasOwnProperty(key) === false) {
-      continue;
+    if (!item) return null;
+    const newItem = {
+        ...item
+    };
+    const targets = attributesToRemove.concat(removeAttributes);
+    const attributes = entity.schema.attributes;
+    for(const key in item)if (false !== item.hasOwnProperty(key)) {
+        if (!attributes[key] || false !== targets.includes(key)) delete newItem[key];
     }
-
-    if (attributes[key] && targets.includes(key) === false) {
-      continue;
-    }
-
-    delete newItem[key];
-  }
-
-  return newItem;
+    return newItem;
 }
-
 function cleanupItems(entity, items, removeAttributes = []) {
-  return items.map(item => cleanupItem(entity, item, removeAttributes));
-}
+    return items.map((item)=>cleanupItem(entity, item, removeAttributes));
+}
+export { cleanupItem, cleanupItems };
+
+//# sourceMappingURL=cleanup.js.map

package/utils/cleanup.js.map

@@ -1 +1 @@
-{"version":3,"names":["attributesToRemove","cleanupItem","entity","item","removeAttributes","newItem","targets","concat","attributes","schema","key","hasOwnProperty","includes","cleanupItems","items","map"],"sources":["cleanup.ts"],"sourcesContent":["import { Entity } from \"dynamodb-toolbox\";\n\n/**\n * The attributes defined by us or the dynamodb-toolbox library.\n * Add more attributes if necessary.\n */\nconst attributesToRemove = [\n    \"PK\",\n    \"SK\",\n    \"created\",\n    \"_ct\",\n    \"modified\",\n    \"_mt\",\n    \"entity\",\n    \"_et\",\n    \"GSI1_PK\",\n    \"GSI1_SK\",\n    \"TYPE\"\n];\n\nexport function cleanupItem<T>(\n    entity: Entity<any>,\n    item?: (T & Record<string, any>) | null,\n    removeAttributes: string[] = []\n): T | null {\n    if (!item) {\n        return null;\n    }\n    const newItem = {\n        ...item\n    };\n    const targets = attributesToRemove.concat(removeAttributes);\n    const attributes = entity.schema.attributes;\n    for (const key in item) {\n        if (item.hasOwnProperty(key) === false) {\n            continue;\n        }\n        if (attributes[key] && targets.includes(key) === false) {\n            continue;\n        }\n        delete newItem[key];\n    }\n    return newItem;\n}\n\nexport function cleanupItems<T>(\n    entity: Entity<any>,\n    items: (T & Record<string, any>)[],\n    removeAttributes: string[] = []\n): T[] {\n    return items.map(item => cleanupItem<T>(entity, item, removeAttributes) as T);\n}\n"],"mappings":";;;;;;;;;;;;AAEA;AACA;AACA;AACA;AACA,MAAMA,kBAAkB,GAAG,CACvB,IADuB,EAEvB,IAFuB,EAGvB,SAHuB,EAIvB,KAJuB,EAKvB,UALuB,EAMvB,KANuB,EAOvB,QAPuB,EAQvB,KARuB,EASvB,SATuB,EAUvB,SAVuB,EAWvB,MAXuB,CAA3B;;AAcO,SAASC,WAAT,CACHC,MADG,EAEHC,IAFG,EAGHC,gBAA0B,GAAG,EAH1B,EAIK;EACR,IAAI,CAACD,IAAL,EAAW;IACP,OAAO,IAAP;EACH;;EACD,MAAME,OAAO,mCACNF,IADM,CAAb;EAGA,MAAMG,OAAO,GAAGN,kBAAkB,CAACO,MAAnB,CAA0BH,gBAA1B,CAAhB;EACA,MAAMI,UAAU,GAAGN,MAAM,CAACO,MAAP,CAAcD,UAAjC;;EACA,KAAK,MAAME,GAAX,IAAkBP,IAAlB,EAAwB;IACpB,IAAIA,IAAI,CAACQ,cAAL,CAAoBD,GAApB,MAA6B,KAAjC,EAAwC;MACpC;IACH;;IACD,IAAIF,UAAU,CAACE,GAAD,CAAV,IAAmBJ,OAAO,CAACM,QAAR,CAAiBF,GAAjB,MAA0B,KAAjD,EAAwD;MACpD;IACH;;IACD,OAAOL,OAAO,CAACK,GAAD,CAAd;EACH;;EACD,OAAOL,OAAP;AACH;;AAEM,SAASQ,YAAT,CACHX,MADG,EAEHY,KAFG,EAGHV,gBAA0B,GAAG,EAH1B,EAIA;EACH,OAAOU,KAAK,CAACC,GAAN,CAAUZ,IAAI,IAAIF,WAAW,CAAIC,MAAJ,EAAYC,IAAZ,EAAkBC,gBAAlB,CAA7B,CAAP;AACH"}
+{"version":3,"file":"utils/cleanup.js","sources":["../../src/utils/cleanup.ts"],"sourcesContent":["import type { Entity } from \"~/toolbox.js\";\n\n/**\n * The attributes defined by us or the dynamodb-toolbox library.\n * Add more attributes if necessary.\n */\nconst attributesToRemove = [\n    \"PK\",\n    \"SK\",\n    \"created\",\n    \"_ct\",\n    \"modified\",\n    \"_mt\",\n    \"entity\",\n    \"_et\",\n    \"GSI1_PK\",\n    \"GSI1_SK\",\n    \"GSI2_PK\",\n    \"GSI2_SK\",\n    \"GSI3_PK\",\n    \"GSI3_SK\",\n    \"GSI4_PK\",\n    \"GSI4_SK\",\n    \"GSI5_PK\",\n    \"GSI5_SK\",\n    \"GSI_TENANT\",\n    \"TYPE\"\n];\n\nexport function cleanupItem<T>(\n    entity: Entity<any>,\n    item?: T | null,\n    removeAttributes: string[] = []\n): T | null {\n    if (!item) {\n        return null;\n    }\n    const newItem = {\n        ...item\n    };\n    const targets = attributesToRemove.concat(removeAttributes);\n    const attributes = entity.schema.attributes;\n    for (const key in item) {\n        if (item.hasOwnProperty(key) === false) {\n            continue;\n        }\n        if (attributes[key] && targets.includes(key) === false) {\n            continue;\n        }\n        delete newItem[key];\n    }\n    return newItem;\n}\n\nexport function cleanupItems<T>(\n    entity: Entity<any>,\n    items: T[],\n    removeAttributes: string[] = []\n): T[] {\n    return items.map(item => cleanupItem<T>(entity, item, removeAttributes) as T);\n}\n"],"names":["attributesToRemove","cleanupItem","entity","item","removeAttributes","newItem","targets","attributes","key","cleanupItems","items"],"mappings":"AAMA,MAAMA,qBAAqB;IACvB;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;CACH;AAEM,SAASC,YACZC,MAAmB,EACnBC,IAAe,EACfC,mBAA6B,EAAE;IAE/B,IAAI,CAACD,MACD,OAAO;IAEX,MAAME,UAAU;QACZ,GAAGF,IAAI;IACX;IACA,MAAMG,UAAUN,mBAAmB,MAAM,CAACI;IAC1C,MAAMG,aAAaL,OAAO,MAAM,CAAC,UAAU;IAC3C,IAAK,MAAMM,OAAOL,KACd,IAAIA,AAA6B,UAA7BA,KAAK,cAAc,CAACK,MAGxB;QAAA,IAAID,CAAAA,UAAU,CAACC,IAAI,IAAIF,AAA0B,UAA1BA,QAAQ,QAAQ,CAACE,MAGxC,OAAOH,OAAO,CAACG,IAAI;IADnB;IAGJ,OAAOH;AACX;AAEO,SAASI,aACZP,MAAmB,EACnBQ,KAAU,EACVN,mBAA6B,EAAE;IAE/B,OAAOM,MAAM,GAAG,CAACP,CAAAA,OAAQF,YAAeC,QAAQC,MAAMC;AAC1D"}

package/utils/count.d.ts

@@ -0,0 +1,2 @@
+import type { QueryAllParams } from "../utils/query.js";
+export declare const count: (params: QueryAllParams) => Promise<number>;

package/utils/count.js

@@ -0,0 +1,11 @@
+const count = async (params)=>{
+    const { entity, partitionKey, options = {} } = params;
+    const { Count } = await entity.query(partitionKey, {
+        ...options,
+        select: "count"
+    });
+    return Count || 0;
+};
+export { count };
+
+//# sourceMappingURL=count.js.map

package/utils/count.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils/count.js","sources":["../../src/utils/count.ts"],"sourcesContent":["import type { QueryAllParams } from \"~/utils/query.js\";\n\nexport const count = async (params: QueryAllParams): Promise<number> => {\n    const { entity, partitionKey, options = {} } = params;\n    // @ts-expect-error\n    const { Count } = await entity.query(partitionKey, { ...options, select: \"count\" });\n    return Count || 0;\n};\n"],"names":["count","params","entity","partitionKey","options","Count"],"mappings":"AAEO,MAAMA,QAAQ,OAAOC;IACxB,MAAM,EAAEC,MAAM,EAAEC,YAAY,EAAEC,UAAU,CAAC,CAAC,EAAE,GAAGH;IAE/C,MAAM,EAAEI,KAAK,EAAE,GAAG,MAAMH,OAAO,KAAK,CAACC,cAAc;QAAE,GAAGC,OAAO;QAAE,QAAQ;IAAQ;IACjF,OAAOC,SAAS;AACpB"}

package/utils/createEntity.d.ts

@@ -0,0 +1,36 @@
+import type { AttributeDefinitions } from "../toolbox.js";
+import { type EntityConstructor } from "../utils/entity/index.js";
+import type { GenericRecord } from "@webiny/api/types.js";
+export type IGlobalEntityAttributes<T = undefined> = {
+    PK: string;
+    SK: string;
+    TYPE: string;
+    GSI1_PK?: string;
+    GSI1_SK?: string;
+    GSI2_PK?: string;
+    GSI2_SK?: string;
+    expiresAt?: number | null;
+} & (T extends undefined ? {
+    data?: undefined;
+} : {
+    data: T;
+});
+export declare const globalEntityAttributes: AttributeDefinitions;
+export declare const createGlobalEntity: <T extends GenericRecord = GenericRecord>(params: Omit<EntityConstructor, "attributes"> & Partial<Pick<EntityConstructor, "attributes">>) => import("~/utils/entity/index.js").IEntity<IGlobalEntityAttributes<T>>;
+export type IStandardEntityAttributes<T = undefined> = {
+    PK: string;
+    SK: string;
+    GSI_TENANT: string;
+    TYPE: string;
+    GSI1_PK?: string;
+    GSI1_SK?: string;
+    GSI2_PK?: string;
+    GSI2_SK?: string;
+    expiresAt?: number | null;
+} & (T extends undefined ? {
+    data?: undefined;
+} : {
+    data: T;
+});
+export declare const standardEntityAttributes: AttributeDefinitions;
+export declare const createStandardEntity: <T extends GenericRecord = GenericRecord>(params: Omit<EntityConstructor, "attributes"> & Partial<Pick<EntityConstructor, "attributes">>) => import("~/utils/entity/index.js").IEntity<IStandardEntityAttributes<T>>;

package/utils/createEntity.js

@@ -0,0 +1,82 @@
+import { createEntity } from "./entity/index.js";
+const globalEntityAttributes = {
+    PK: {
+        partitionKey: true
+    },
+    SK: {
+        sortKey: true
+    },
+    GSI1_PK: {
+        type: "string"
+    },
+    GSI1_SK: {
+        type: "string"
+    },
+    GSI2_PK: {
+        type: "string"
+    },
+    GSI2_SK: {
+        type: "string"
+    },
+    TYPE: {
+        type: "string",
+        required: true
+    },
+    data: {
+        type: "map"
+    },
+    expiresAt: {
+        type: "number"
+    }
+};
+const createGlobalEntity = (params)=>createEntity({
+        ...params,
+        attributes: {
+            ...globalEntityAttributes,
+            ...params.attributes
+        }
+    });
+const standardEntityAttributes = {
+    PK: {
+        partitionKey: true
+    },
+    SK: {
+        sortKey: true
+    },
+    GSI_TENANT: {
+        type: "string",
+        required: true
+    },
+    GSI1_PK: {
+        type: "string"
+    },
+    GSI1_SK: {
+        type: "string"
+    },
+    GSI2_PK: {
+        type: "string"
+    },
+    GSI2_SK: {
+        type: "string"
+    },
+    TYPE: {
+        type: "string",
+        required: true
+    },
+    data: {
+        type: "map"
+    },
+    expiresAt: {
+        type: "number"
+    }
+};
+const createStandardEntity = (params)=>createEntity({
+        ...params,
+        attributes: {
+            ...standardEntityAttributes,
+            ...params.attributes
+        }
+    });
+export { createGlobalEntity, createStandardEntity, globalEntityAttributes, standardEntityAttributes };
+
+//# sourceMappingURL=createEntity.js.map

package/utils/createEntity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils/createEntity.js","sources":["../../src/utils/createEntity.ts"],"sourcesContent":["import type { AttributeDefinitions } from \"~/toolbox.js\";\nimport { createEntity, type EntityConstructor } from \"~/utils/entity/index.js\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\n\nexport type IGlobalEntityAttributes<T = undefined> = {\n    PK: string;\n    SK: string;\n    TYPE: string;\n    GSI1_PK?: string;\n    GSI1_SK?: string;\n    GSI2_PK?: string;\n    GSI2_SK?: string;\n    expiresAt?: number | null;\n} & (T extends undefined ? { data?: undefined } : { data: T });\n\nexport const globalEntityAttributes: AttributeDefinitions = {\n    PK: {\n        partitionKey: true\n    },\n    SK: {\n        sortKey: true\n    },\n    GSI1_PK: {\n        type: \"string\"\n    },\n    GSI1_SK: {\n        type: \"string\"\n    },\n    GSI2_PK: {\n        type: \"string\"\n    },\n    GSI2_SK: {\n        type: \"string\"\n    },\n    TYPE: {\n        type: \"string\",\n        required: true\n    },\n    data: {\n        type: \"map\"\n    },\n    expiresAt: {\n        type: \"number\"\n    }\n};\n\nexport const createGlobalEntity = <T extends GenericRecord = GenericRecord>(\n    params: Omit<EntityConstructor, \"attributes\"> & Partial<Pick<EntityConstructor, \"attributes\">>\n) => {\n    return createEntity<IGlobalEntityAttributes<T>>({\n        ...params,\n        attributes: {\n            ...globalEntityAttributes,\n            ...params.attributes\n        }\n    });\n};\n\nexport type IStandardEntityAttributes<T = undefined> = {\n    PK: string;\n    SK: string;\n    GSI_TENANT: string;\n    TYPE: string;\n    GSI1_PK?: string;\n    GSI1_SK?: string;\n    GSI2_PK?: string;\n    GSI2_SK?: string;\n    expiresAt?: number | null;\n} & (T extends undefined ? { data?: undefined } : { data: T });\n\nexport const standardEntityAttributes: AttributeDefinitions = {\n    PK: {\n        partitionKey: true\n    },\n    SK: {\n        sortKey: true\n    },\n    GSI_TENANT: {\n        type: \"string\",\n        required: true\n    },\n    GSI1_PK: {\n        type: \"string\"\n    },\n    GSI1_SK: {\n        type: \"string\"\n    },\n    GSI2_PK: {\n        type: \"string\"\n    },\n    GSI2_SK: {\n        type: \"string\"\n    },\n    TYPE: {\n        type: \"string\",\n        required: true\n    },\n    data: {\n        type: \"map\"\n    },\n    expiresAt: {\n        type: \"number\"\n    }\n};\n\nexport const createStandardEntity = <T extends GenericRecord = GenericRecord>(\n    params: Omit<EntityConstructor, \"attributes\"> & Partial<Pick<EntityConstructor, \"attributes\">>\n) => {\n    return createEntity<IStandardEntityAttributes<T>>({\n        ...params,\n        attributes: {\n            ...standardEntityAttributes,\n            ...params.attributes\n        }\n    });\n};\n"],"names":["globalEntityAttributes","createGlobalEntity","params","createEntity","standardEntityAttributes","createStandardEntity"],"mappings":";AAeO,MAAMA,yBAA+C;IACxD,IAAI;QACA,cAAc;IAClB;IACA,IAAI;QACA,SAAS;IACb;IACA,SAAS;QACL,MAAM;IACV;IACA,SAAS;QACL,MAAM;IACV;IACA,SAAS;QACL,MAAM;IACV;IACA,SAAS;QACL,MAAM;IACV;IACA,MAAM;QACF,MAAM;QACN,UAAU;IACd;IACA,MAAM;QACF,MAAM;IACV;IACA,WAAW;QACP,MAAM;IACV;AACJ;AAEO,MAAMC,qBAAqB,CAC9BC,SAEOC,aAAyC;QAC5C,GAAGD,MAAM;QACT,YAAY;YACR,GAAGF,sBAAsB;YACzB,GAAGE,OAAO,UAAU;QACxB;IACJ;AAeG,MAAME,2BAAiD;IAC1D,IAAI;QACA,cAAc;IAClB;IACA,IAAI;QACA,SAAS;IACb;IACA,YAAY;QACR,MAAM;QACN,UAAU;IACd;IACA,SAAS;QACL,MAAM;IACV;IACA,SAAS;QACL,MAAM;IACV;IACA,SAAS;QACL,MAAM;IACV;IACA,SAAS;QACL,MAAM;IACV;IACA,MAAM;QACF,MAAM;QACN,UAAU;IACd;IACA,MAAM;QACF,MAAM;IACV;IACA,WAAW;QACP,MAAM;IACV;AACJ;AAEO,MAAMC,uBAAuB,CAChCH,SAEOC,aAA2C;QAC9C,GAAGD,MAAM;QACT,YAAY;YACR,GAAGE,wBAAwB;YAC3B,GAAGF,OAAO,UAAU;QACxB;IACJ"}

package/utils/createTable.d.ts

@@ -0,0 +1,11 @@
+import type { ITable } from "../utils/table/index.js";
+import type { TableConstructor } from "../toolbox.js";
+export interface ICreateTableParamsIndexDefinition {
+    partitionKey: string;
+    sortKey?: string;
+}
+export type ICreateTableParams = Partial<Omit<TableConstructor<string, string, string>, "DocumentClient">> & {
+    name: string;
+    documentClient: Pick<TableConstructor<string, string, string>, "DocumentClient">["DocumentClient"];
+};
+export declare const createTable: (params: ICreateTableParams) => ITable<string, "PK", "SK">;

package/utils/createTable.js

@@ -0,0 +1,29 @@
+import { Table } from "./table/index.js";
+const createTable = (params)=>{
+    const { documentClient, indexes = {}, ...rest } = params;
+    return new Table({
+        partitionKey: "PK",
+        sortKey: "SK",
+        DocumentClient: documentClient,
+        indexes: {
+            GSI_TENANT: {
+                partitionKey: "GSI_TENANT"
+            },
+            GSI1: {
+                partitionKey: "GSI1_PK",
+                sortKey: "GSI1_SK"
+            },
+            GSI2: {
+                partitionKey: "GSI2_PK",
+                sortKey: "GSI2_SK"
+            },
+            ...indexes
+        },
+        autoExecute: true,
+        autoParse: true,
+        ...rest
+    });
+};
+export { createTable };
+
+//# sourceMappingURL=createTable.js.map

package/utils/createTable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils/createTable.js","sources":["../../src/utils/createTable.ts"],"sourcesContent":["import type { ITable } from \"~/utils/table/index.js\";\nimport { Table } from \"~/utils/table/index.js\";\nimport type { TableConstructor } from \"~/toolbox.js\";\n\nexport interface ICreateTableParamsIndexDefinition {\n    partitionKey: string;\n    sortKey?: string;\n}\n\n// export interface ICreateTableParams {\n//     name?: string;\n//     documentClient: DynamoDBDocument;\n//     indexes?: GenericRecord<string, ICreateTableParamsIndexDefinition>;\n// }\n\nexport type ICreateTableParams = Partial<\n    Omit<TableConstructor<string, string, string>, \"DocumentClient\">\n> & {\n    name: string;\n    documentClient: Pick<\n        TableConstructor<string, string, string>,\n        \"DocumentClient\"\n    >[\"DocumentClient\"];\n};\n\nexport const createTable = (params: ICreateTableParams): ITable<string, \"PK\", \"SK\"> => {\n    const { documentClient, indexes = {}, ...rest } = params;\n    return new Table({\n        partitionKey: \"PK\",\n        sortKey: \"SK\",\n        DocumentClient: documentClient,\n        indexes: {\n            GSI_TENANT: {\n                partitionKey: \"GSI_TENANT\"\n            },\n            GSI1: {\n                partitionKey: \"GSI1_PK\",\n                sortKey: \"GSI1_SK\"\n            },\n            GSI2: {\n                partitionKey: \"GSI2_PK\",\n                sortKey: \"GSI2_SK\"\n            },\n            ...indexes\n        },\n        autoExecute: true,\n        autoParse: true,\n        ...rest\n    });\n};\n"],"names":["createTable","params","documentClient","indexes","rest","Table"],"mappings":";AAyBO,MAAMA,cAAc,CAACC;IACxB,MAAM,EAAEC,cAAc,EAAEC,UAAU,CAAC,CAAC,EAAE,GAAGC,MAAM,GAAGH;IAClD,OAAO,IAAII,MAAM;QACb,cAAc;QACd,SAAS;QACT,gBAAgBH;QAChB,SAAS;YACL,YAAY;gBACR,cAAc;YAClB;YACA,MAAM;gBACF,cAAc;gBACd,SAAS;YACb;YACA,MAAM;gBACF,cAAc;gBACd,SAAS;YACb;YACA,GAAGC,OAAO;QACd;QACA,aAAa;QACb,WAAW;QACX,GAAGC,IAAI;IACX;AACJ"}

package/utils/cursor.js

@@ -1,26 +1,11 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.encodeCursor = exports.decodeCursor = void 0;
-
-const encodeCursor = cursor => {
-  if (!cursor) {
-    return null;
-  }
-
-  return Buffer.from(JSON.stringify(cursor)).toString("base64");
+const encodeCursor = (cursor)=>{
+    if (!cursor) return null;
+    return Buffer.from(JSON.stringify(cursor)).toString("base64");
 };
-
-exports.encodeCursor = encodeCursor;
-
-const decodeCursor = cursor => {
-  if (!cursor) {
-    return null;
-  }
-
-  return JSON.parse(Buffer.from(cursor, "base64").toString("ascii"));
+const decodeCursor = (cursor)=>{
+    if (!cursor) return null;
+    return JSON.parse(Buffer.from(cursor, "base64").toString("ascii"));
 };
+export { decodeCursor, encodeCursor };
 
-exports.decodeCursor = decodeCursor;
+//# sourceMappingURL=cursor.js.map

package/utils/cursor.js.map

@@ -1 +1 @@
-{"version":3,"names":["encodeCursor","cursor","Buffer","from","JSON","stringify","toString","decodeCursor","parse"],"sources":["cursor.ts"],"sourcesContent":["export const encodeCursor = (cursor?: any): string | null => {\n    if (!cursor) {\n        return null;\n    }\n\n    return Buffer.from(JSON.stringify(cursor)).toString(\"base64\");\n};\n\nexport const decodeCursor = (cursor?: string | null): string | null => {\n    if (!cursor) {\n        return null;\n    }\n\n    return JSON.parse(Buffer.from(cursor, \"base64\").toString(\"ascii\"));\n};\n"],"mappings":";;;;;;;AAAO,MAAMA,YAAY,GAAIC,MAAD,IAAiC;EACzD,IAAI,CAACA,MAAL,EAAa;IACT,OAAO,IAAP;EACH;;EAED,OAAOC,MAAM,CAACC,IAAP,CAAYC,IAAI,CAACC,SAAL,CAAeJ,MAAf,CAAZ,EAAoCK,QAApC,CAA6C,QAA7C,CAAP;AACH,CANM;;;;AAQA,MAAMC,YAAY,GAAIN,MAAD,IAA2C;EACnE,IAAI,CAACA,MAAL,EAAa;IACT,OAAO,IAAP;EACH;;EAED,OAAOG,IAAI,CAACI,KAAL,CAAWN,MAAM,CAACC,IAAP,CAAYF,MAAZ,EAAoB,QAApB,EAA8BK,QAA9B,CAAuC,OAAvC,CAAX,CAAP;AACH,CANM"}
+{"version":3,"file":"utils/cursor.js","sources":["../../src/utils/cursor.ts"],"sourcesContent":["export const encodeCursor = (cursor?: any): string | null => {\n    if (!cursor) {\n        return null;\n    }\n\n    return Buffer.from(JSON.stringify(cursor)).toString(\"base64\");\n};\n\nexport const decodeCursor = (cursor?: string | null): string | null => {\n    if (!cursor) {\n        return null;\n    }\n\n    return JSON.parse(Buffer.from(cursor, \"base64\").toString(\"ascii\"));\n};\n"],"names":["encodeCursor","cursor","Buffer","JSON","decodeCursor"],"mappings":"AAAO,MAAMA,eAAe,CAACC;IACzB,IAAI,CAACA,QACD,OAAO;IAGX,OAAOC,OAAO,IAAI,CAACC,KAAK,SAAS,CAACF,SAAS,QAAQ,CAAC;AACxD;AAEO,MAAMG,eAAe,CAACH;IACzB,IAAI,CAACA,QACD,OAAO;IAGX,OAAOE,KAAK,KAAK,CAACD,OAAO,IAAI,CAACD,QAAQ,UAAU,QAAQ,CAAC;AAC7D"}