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

package/utils/delete.d.ts

@@ -0,0 +1,10 @@
+import type { Entity } from "../toolbox.js";
+export interface IDeleteItemKeys {
+    PK: string;
+    SK: string;
+}
+export interface IDeleteItemParams {
+    entity: Entity;
+    keys: IDeleteItemKeys;
+}
+export declare const deleteItem: (params: IDeleteItemParams) => Promise<import("@aws-sdk/lib-dynamodb").DeleteCommandOutput>;

package/utils/delete.js

@@ -0,0 +1,9 @@
+const deleteItem = async (params)=>{
+    const { entity, keys } = params;
+    return await entity.delete(keys, {
+        execute: true
+    });
+};
+export { deleteItem };
+
+//# sourceMappingURL=delete.js.map

package/utils/delete.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils/delete.js","sources":["../../src/utils/delete.ts"],"sourcesContent":["import type { Entity } from \"~/toolbox.js\";\nexport interface IDeleteItemKeys {\n    PK: string;\n    SK: string;\n}\nexport interface IDeleteItemParams {\n    entity: Entity;\n    keys: IDeleteItemKeys;\n}\n\nexport const deleteItem = async (params: IDeleteItemParams) => {\n    const { entity, keys } = params;\n\n    return await entity.delete(keys, {\n        execute: true\n    });\n};\n"],"names":["deleteItem","params","entity","keys"],"mappings":"AAUO,MAAMA,aAAa,OAAOC;IAC7B,MAAM,EAAEC,MAAM,EAAEC,IAAI,EAAE,GAAGF;IAEzB,OAAO,MAAMC,OAAO,MAAM,CAACC,MAAM;QAC7B,SAAS;IACb;AACJ"}

package/utils/entity/Entity.d.ts

@@ -0,0 +1,28 @@
+import type { AttributeDefinitions, EntityConstructor as BaseEntityConstructor, Readonly, TableDef } from "../../toolbox.js";
+import { Entity as BaseEntity } from "../../toolbox.js";
+import type { ITableWriteBatch } from "../table/types.js";
+import type { IEntity, IEntityCreateEntityReaderParams, IEntityCreateEntityWriterParams, IEntityDeleteResult, IEntityGetCleanResult, IEntityGetResult, IEntityPutResult, IEntityQueryAllCleanResult, IEntityQueryAllParams, IEntityQueryAllResult, IEntityQueryOneCleanResult, IEntityQueryOneParams, IEntityQueryOneResult, IEntityQueryPerPageParams, IEntityReadBatch, IEntityWriteBatch } from "./types.js";
+import type { IPutParamsItem } from "../put.js";
+import type { GetRecordParamsKeys } from "../get.js";
+import type { IDeleteItemKeys } from "../delete.js";
+import type { GenericRecord } from "@webiny/api/types.js";
+export type EntityConstructor<T extends Readonly<AttributeDefinitions> = Readonly<AttributeDefinitions>> = BaseEntityConstructor<T>;
+export declare class Entity<T extends GenericRecord = GenericRecord> implements IEntity<T> {
+    readonly entity: BaseEntity;
+    get name(): string;
+    get table(): TableDef;
+    constructor(params: EntityConstructor);
+    createEntityReader(params?: IEntityCreateEntityReaderParams): IEntityReadBatch<T>;
+    createEntityWriter(params?: IEntityCreateEntityWriterParams): IEntityWriteBatch<T>;
+    createTableWriter(): ITableWriteBatch;
+    put<T extends GenericRecord = GenericRecord>(item: IPutParamsItem<T>): IEntityPutResult;
+    get<T>(keys: GetRecordParamsKeys): IEntityGetResult<T>;
+    getClean<T>(keys: GetRecordParamsKeys): IEntityGetCleanResult<T>;
+    delete(keys: IDeleteItemKeys): IEntityDeleteResult;
+    queryOne<T>(params: IEntityQueryOneParams): IEntityQueryOneResult<T>;
+    queryOneClean<T>(params: IEntityQueryOneParams): IEntityQueryOneCleanResult<T>;
+    queryAll<T>(params: IEntityQueryAllParams): IEntityQueryAllResult<T>;
+    queryAllClean<T>(params: IEntityQueryAllParams): IEntityQueryAllCleanResult<T>;
+    queryPerPage<T>(params: IEntityQueryPerPageParams): Promise<import("../query.js").IQueryPageResponse<T>>;
+}
+export declare const createEntity: <T extends GenericRecord = GenericRecord>(params: EntityConstructor) => IEntity<T>;

package/utils/entity/Entity.js

@@ -0,0 +1,95 @@
+import { Entity } from "../../toolbox.js";
+import { put } from "../put.js";
+import { get, getClean } from "../get.js";
+import { deleteItem } from "../delete.js";
+import { createEntityReadBatch } from "./EntityReadBatch.js";
+import { createEntityWriteBatch } from "./EntityWriteBatch.js";
+import { createTableWriteBatch } from "../table/TableWriteBatch.js";
+import { queryAll, queryAllClean, queryOne, queryOneClean, queryPerPage } from "../query.js";
+class Entity_Entity {
+    get name() {
+        return this.entity.name;
+    }
+    get table() {
+        return this.entity.table;
+    }
+    constructor(params){
+        this.entity = new Entity(params);
+    }
+    createEntityReader(params) {
+        return createEntityReadBatch({
+            entity: this.entity,
+            read: params?.read
+        });
+    }
+    createEntityWriter(params) {
+        return createEntityWriteBatch({
+            entity: this.entity,
+            put: params?.put,
+            delete: params?.delete
+        });
+    }
+    createTableWriter() {
+        return createTableWriteBatch({
+            table: this.entity.table
+        });
+    }
+    async put(item) {
+        return put({
+            entity: this.entity,
+            item
+        });
+    }
+    async get(keys) {
+        return get({
+            entity: this.entity,
+            keys
+        });
+    }
+    async getClean(keys) {
+        return getClean({
+            entity: this.entity,
+            keys
+        });
+    }
+    async delete(keys) {
+        return deleteItem({
+            entity: this.entity,
+            keys
+        });
+    }
+    async queryOne(params) {
+        return queryOne({
+            ...params,
+            entity: this.entity
+        });
+    }
+    async queryOneClean(params) {
+        return queryOneClean({
+            ...params,
+            entity: this.entity
+        });
+    }
+    async queryAll(params) {
+        return queryAll({
+            ...params,
+            entity: this.entity
+        });
+    }
+    async queryAllClean(params) {
+        return queryAllClean({
+            ...params,
+            entity: this.entity
+        });
+    }
+    async queryPerPage(params) {
+        return queryPerPage({
+            ...params,
+            entity: this.entity
+        });
+    }
+}
+const createEntity = (params)=>new Entity_Entity(params);
+export { Entity_Entity as Entity, createEntity };
+
+//# sourceMappingURL=Entity.js.map

package/utils/entity/Entity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils/entity/Entity.js","sources":["../../../src/utils/entity/Entity.ts"],"sourcesContent":["import type {\n    AttributeDefinitions,\n    EntityConstructor as BaseEntityConstructor,\n    Readonly,\n    TableDef\n} from \"~/toolbox.js\";\nimport { Entity as BaseEntity } from \"~/toolbox.js\";\nimport type { ITableWriteBatch } from \"../table/types.js\";\nimport type {\n    IEntity,\n    IEntityCreateEntityReaderParams,\n    IEntityCreateEntityWriterParams,\n    IEntityDeleteResult,\n    IEntityGetCleanResult,\n    IEntityGetResult,\n    IEntityPutResult,\n    IEntityQueryAllCleanResult,\n    IEntityQueryAllParams,\n    IEntityQueryAllResult,\n    IEntityQueryOneCleanResult,\n    IEntityQueryOneParams,\n    IEntityQueryOneResult,\n    IEntityQueryPerPageParams,\n    IEntityReadBatch,\n    IEntityWriteBatch\n} from \"./types.js\";\nimport type { IPutParamsItem } from \"../put.js\";\nimport { put } from \"../put.js\";\nimport type { GetRecordParamsKeys } from \"../get.js\";\nimport { get, getClean } from \"../get.js\";\nimport type { IDeleteItemKeys } from \"../delete.js\";\nimport { deleteItem } from \"../delete.js\";\nimport { createEntityReadBatch } from \"./EntityReadBatch.js\";\nimport { createEntityWriteBatch } from \"./EntityWriteBatch.js\";\nimport { createTableWriteBatch } from \"~/utils/table/TableWriteBatch.js\";\nimport { queryAll, queryAllClean, queryOne, queryOneClean, queryPerPage } from \"../query.js\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\n\nexport type EntityConstructor<\n    T extends Readonly<AttributeDefinitions> = Readonly<AttributeDefinitions>\n> = BaseEntityConstructor<T>;\n\nexport class Entity<T extends GenericRecord = GenericRecord> implements IEntity<T> {\n    public readonly entity: BaseEntity;\n\n    public get name(): string {\n        return this.entity.name;\n    }\n\n    public get table(): TableDef {\n        /**\n         * Not possible to be undefined.\n         */\n        return this.entity.table!;\n    }\n\n    public constructor(params: EntityConstructor) {\n        // @ts-expect-error\n        this.entity = new BaseEntity(params);\n    }\n\n    public createEntityReader(params?: IEntityCreateEntityReaderParams): IEntityReadBatch<T> {\n        return createEntityReadBatch({\n            entity: this.entity,\n            read: params?.read\n        });\n    }\n\n    public createEntityWriter(params?: IEntityCreateEntityWriterParams): IEntityWriteBatch<T> {\n        return createEntityWriteBatch({\n            entity: this.entity,\n            put: params?.put,\n            delete: params?.delete\n        });\n    }\n\n    public createTableWriter(): ITableWriteBatch {\n        return createTableWriteBatch({\n            table: this.entity.table as TableDef\n        });\n    }\n\n    public async put<T extends GenericRecord = GenericRecord>(\n        item: IPutParamsItem<T>\n    ): IEntityPutResult {\n        return put({\n            entity: this.entity,\n            item\n        });\n    }\n\n    public async get<T>(keys: GetRecordParamsKeys): IEntityGetResult<T> {\n        return get<T>({\n            entity: this.entity,\n            keys\n        });\n    }\n\n    public async getClean<T>(keys: GetRecordParamsKeys): IEntityGetCleanResult<T> {\n        return getClean<T>({\n            entity: this.entity,\n            keys\n        });\n    }\n\n    public async delete(keys: IDeleteItemKeys): IEntityDeleteResult {\n        return deleteItem({\n            entity: this.entity,\n            keys\n        });\n    }\n\n    public async queryOne<T>(params: IEntityQueryOneParams): IEntityQueryOneResult<T> {\n        return queryOne<T>({\n            ...params,\n            entity: this.entity\n        });\n    }\n\n    public async queryOneClean<T>(params: IEntityQueryOneParams): IEntityQueryOneCleanResult<T> {\n        return queryOneClean<T>({\n            ...params,\n            entity: this.entity\n        });\n    }\n\n    public async queryAll<T>(params: IEntityQueryAllParams): IEntityQueryAllResult<T> {\n        return queryAll<T>({\n            ...params,\n            entity: this.entity\n        });\n    }\n\n    public async queryAllClean<T>(params: IEntityQueryAllParams): IEntityQueryAllCleanResult<T> {\n        return queryAllClean<T>({\n            ...params,\n            entity: this.entity\n        });\n    }\n\n    public async queryPerPage<T>(params: IEntityQueryPerPageParams) {\n        return queryPerPage<T>({\n            ...params,\n            entity: this.entity\n        });\n    }\n}\n\nexport const createEntity = <T extends GenericRecord = GenericRecord>(\n    params: EntityConstructor\n): IEntity<T> => {\n    return new Entity<T>(params);\n};\n"],"names":["Entity","params","BaseEntity","createEntityReadBatch","createEntityWriteBatch","createTableWriteBatch","item","put","keys","get","getClean","deleteItem","queryOne","queryOneClean","queryAll","queryAllClean","queryPerPage","createEntity"],"mappings":";;;;;;;;AA0CO,MAAMA;IAGT,IAAW,OAAe;QACtB,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI;IAC3B;IAEA,IAAW,QAAkB;QAIzB,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK;IAC5B;IAEA,YAAmBC,MAAyB,CAAE;QAE1C,IAAI,CAAC,MAAM,GAAG,IAAIC,OAAWD;IACjC;IAEO,mBAAmBA,MAAwC,EAAuB;QACrF,OAAOE,sBAAsB;YACzB,QAAQ,IAAI,CAAC,MAAM;YACnB,MAAMF,QAAQ;QAClB;IACJ;IAEO,mBAAmBA,MAAwC,EAAwB;QACtF,OAAOG,uBAAuB;YAC1B,QAAQ,IAAI,CAAC,MAAM;YACnB,KAAKH,QAAQ;YACb,QAAQA,QAAQ;QACpB;IACJ;IAEO,oBAAsC;QACzC,OAAOI,sBAAsB;YACzB,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK;QAC5B;IACJ;IAEA,MAAa,IACTC,IAAuB,EACP;QAChB,OAAOC,IAAI;YACP,QAAQ,IAAI,CAAC,MAAM;YACnBD;QACJ;IACJ;IAEA,MAAa,IAAOE,IAAyB,EAAuB;QAChE,OAAOC,IAAO;YACV,QAAQ,IAAI,CAAC,MAAM;YACnBD;QACJ;IACJ;IAEA,MAAa,SAAYA,IAAyB,EAA4B;QAC1E,OAAOE,SAAY;YACf,QAAQ,IAAI,CAAC,MAAM;YACnBF;QACJ;IACJ;IAEA,MAAa,OAAOA,IAAqB,EAAuB;QAC5D,OAAOG,WAAW;YACd,QAAQ,IAAI,CAAC,MAAM;YACnBH;QACJ;IACJ;IAEA,MAAa,SAAYP,MAA6B,EAA4B;QAC9E,OAAOW,SAAY;YACf,GAAGX,MAAM;YACT,QAAQ,IAAI,CAAC,MAAM;QACvB;IACJ;IAEA,MAAa,cAAiBA,MAA6B,EAAiC;QACxF,OAAOY,cAAiB;YACpB,GAAGZ,MAAM;YACT,QAAQ,IAAI,CAAC,MAAM;QACvB;IACJ;IAEA,MAAa,SAAYA,MAA6B,EAA4B;QAC9E,OAAOa,SAAY;YACf,GAAGb,MAAM;YACT,QAAQ,IAAI,CAAC,MAAM;QACvB;IACJ;IAEA,MAAa,cAAiBA,MAA6B,EAAiC;QACxF,OAAOc,cAAiB;YACpB,GAAGd,MAAM;YACT,QAAQ,IAAI,CAAC,MAAM;QACvB;IACJ;IAEA,MAAa,aAAgBA,MAAiC,EAAE;QAC5D,OAAOe,aAAgB;YACnB,GAAGf,MAAM;YACT,QAAQ,IAAI,CAAC,MAAM;QACvB;IACJ;AACJ;AAEO,MAAMgB,eAAe,CACxBhB,SAEO,IAAID,cAAUC"}

package/utils/entity/EntityReadBatch.d.ts

@@ -0,0 +1,18 @@
+import type { IReadBatchItem } from "../../utils/batch/types.js";
+import type { IEntityReadBatch, IEntityReadBatchBuilderGetResponse, IEntityReadBatchKey } from "./types.js";
+import type { EntityOption } from "./getEntity.js";
+export interface IEntityReadBatchParams {
+    entity: EntityOption;
+    read?: IReadBatchItem[];
+}
+export declare class EntityReadBatch<T> implements IEntityReadBatch<T> {
+    private readonly entity;
+    private readonly builder;
+    private readonly _items;
+    get total(): number;
+    get items(): IEntityReadBatchBuilderGetResponse[];
+    constructor(params: IEntityReadBatchParams);
+    get(input: IEntityReadBatchKey | IEntityReadBatchKey[]): void;
+    execute(): Promise<T[]>;
+}
+export declare const createEntityReadBatch: <T>(params: IEntityReadBatchParams) => IEntityReadBatch<T>;

package/utils/entity/EntityReadBatch.js

@@ -0,0 +1,31 @@
+import { batchReadAll } from "../batch/batchRead.js";
+import { createEntityReadBatchBuilder } from "./EntityReadBatchBuilder.js";
+import { getEntity } from "./getEntity.js";
+class EntityReadBatch {
+    get total() {
+        return this._items.length;
+    }
+    get items() {
+        return Array.from(this._items);
+    }
+    constructor(params){
+        this._items = [];
+        this.entity = getEntity(params.entity);
+        this.builder = createEntityReadBatchBuilder(this.entity);
+        for (const item of params.read || [])this.get(item);
+    }
+    get(input) {
+        if (Array.isArray(input)) return void this._items.push(...input.map((item)=>this.builder.get(item)));
+        this._items.push(this.builder.get(input));
+    }
+    async execute() {
+        return await batchReadAll({
+            table: this.entity.table,
+            items: this._items
+        });
+    }
+}
+const createEntityReadBatch = (params)=>new EntityReadBatch(params);
+export { EntityReadBatch, createEntityReadBatch };
+
+//# sourceMappingURL=EntityReadBatch.js.map

package/utils/entity/EntityReadBatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils/entity/EntityReadBatch.js","sources":["../../../src/utils/entity/EntityReadBatch.ts"],"sourcesContent":["import type { IReadBatchItem } from \"~/utils/batch/types.js\";\nimport type {\n    IEntityReadBatch,\n    IEntityReadBatchBuilder,\n    IEntityReadBatchBuilderGetResponse,\n    IEntityReadBatchKey\n} from \"./types.js\";\nimport type { Entity as ToolboxEntity, TableDef } from \"~/toolbox.js\";\nimport { batchReadAll } from \"~/utils/batch/batchRead.js\";\nimport { createEntityReadBatchBuilder } from \"./EntityReadBatchBuilder.js\";\nimport type { EntityOption } from \"./getEntity.js\";\nimport { getEntity } from \"./getEntity.js\";\n\nexport interface IEntityReadBatchParams {\n    entity: EntityOption;\n    read?: IReadBatchItem[];\n}\n\nexport class EntityReadBatch<T> implements IEntityReadBatch<T> {\n    private readonly entity: ToolboxEntity;\n    private readonly builder: IEntityReadBatchBuilder;\n    private readonly _items: IEntityReadBatchBuilderGetResponse[] = [];\n\n    public get total(): number {\n        return this._items.length;\n    }\n\n    public get items(): IEntityReadBatchBuilderGetResponse[] {\n        return Array.from(this._items);\n    }\n\n    public constructor(params: IEntityReadBatchParams) {\n        this.entity = getEntity(params.entity);\n        this.builder = createEntityReadBatchBuilder(this.entity);\n        for (const item of params.read || []) {\n            this.get(item);\n        }\n    }\n\n    public get(input: IEntityReadBatchKey | IEntityReadBatchKey[]): void {\n        if (Array.isArray(input)) {\n            this._items.push(\n                ...input.map(item => {\n                    return this.builder.get(item);\n                })\n            );\n            return;\n        }\n        this._items.push(this.builder.get(input));\n    }\n\n    public async execute() {\n        return await batchReadAll<T>({\n            table: this.entity.table as TableDef,\n            items: this._items\n        });\n    }\n}\n\nexport const createEntityReadBatch = <T>(params: IEntityReadBatchParams): IEntityReadBatch<T> => {\n    return new EntityReadBatch<T>(params);\n};\n"],"names":["EntityReadBatch","Array","params","getEntity","createEntityReadBatchBuilder","item","input","batchReadAll","createEntityReadBatch"],"mappings":";;;AAkBO,MAAMA;IAKT,IAAW,QAAgB;QACvB,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM;IAC7B;IAEA,IAAW,QAA8C;QACrD,OAAOC,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM;IACjC;IAEA,YAAmBC,MAA8B,CAAE;aAVlC,MAAM,GAAyC,EAAE;QAW9D,IAAI,CAAC,MAAM,GAAGC,UAAUD,OAAO,MAAM;QACrC,IAAI,CAAC,OAAO,GAAGE,6BAA6B,IAAI,CAAC,MAAM;QACvD,KAAK,MAAMC,QAAQH,OAAO,IAAI,IAAI,EAAE,CAChC,IAAI,CAAC,GAAG,CAACG;IAEjB;IAEO,IAAIC,KAAkD,EAAQ;QACjE,IAAIL,MAAM,OAAO,CAACK,QAAQ,YACtB,IAAI,CAAC,MAAM,CAAC,IAAI,IACTA,MAAM,GAAG,CAACD,CAAAA,OACF,IAAI,CAAC,OAAO,CAAC,GAAG,CAACA;QAKpC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAACC;IACtC;IAEA,MAAa,UAAU;QACnB,OAAO,MAAMC,aAAgB;YACzB,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK;YACxB,OAAO,IAAI,CAAC,MAAM;QACtB;IACJ;AACJ;AAEO,MAAMC,wBAAwB,CAAIN,SAC9B,IAAIF,gBAAmBE"}

package/utils/entity/EntityReadBatchBuilder.d.ts

@@ -0,0 +1,10 @@
+import type { Entity as ToolboxEntity } from "../../toolbox.js";
+import type { IEntityReadBatchBuilder, IEntityReadBatchBuilderGetResponse, IEntityReadBatchKey } from "./types.js";
+import type { Entity } from "./Entity.js";
+import type { EntityOption } from "./getEntity.js";
+export declare class EntityReadBatchBuilder implements IEntityReadBatchBuilder {
+    private readonly entity;
+    constructor(entity: EntityOption);
+    get(item: IEntityReadBatchKey): IEntityReadBatchBuilderGetResponse;
+}
+export declare const createEntityReadBatchBuilder: (entity: ToolboxEntity | Entity) => IEntityReadBatchBuilder;

package/utils/entity/EntityReadBatchBuilder.js

@@ -0,0 +1,18 @@
+import { WebinyError } from "@webiny/error";
+import { getEntity } from "./getEntity.js";
+class EntityReadBatchBuilder {
+    constructor(entity){
+        this.entity = getEntity(entity);
+    }
+    get(item) {
+        const result = this.entity.getBatch(item);
+        if (result.Table) {
+            if (!result.Key) throw new WebinyError(`No key provided for entity ${this.entity.name}.`);
+        } else throw new WebinyError(`No table provided for entity ${this.entity.name}.`);
+        return result;
+    }
+}
+const createEntityReadBatchBuilder = (entity)=>new EntityReadBatchBuilder(entity);
+export { EntityReadBatchBuilder, createEntityReadBatchBuilder };
+
+//# sourceMappingURL=EntityReadBatchBuilder.js.map

package/utils/entity/EntityReadBatchBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils/entity/EntityReadBatchBuilder.js","sources":["../../../src/utils/entity/EntityReadBatchBuilder.ts"],"sourcesContent":["import type { Entity as ToolboxEntity } from \"~/toolbox.js\";\nimport type {\n    IEntityReadBatchBuilder,\n    IEntityReadBatchBuilderGetResponse,\n    IEntityReadBatchKey\n} from \"./types.js\";\nimport { WebinyError } from \"@webiny/error\";\nimport type { Entity } from \"./Entity.js\";\nimport type { EntityOption } from \"./getEntity.js\";\nimport { getEntity } from \"./getEntity.js\";\n\nexport class EntityReadBatchBuilder implements IEntityReadBatchBuilder {\n    private readonly entity: ToolboxEntity;\n\n    public constructor(entity: EntityOption) {\n        this.entity = getEntity(entity);\n    }\n\n    public get(item: IEntityReadBatchKey): IEntityReadBatchBuilderGetResponse {\n        const result = this.entity.getBatch(item);\n        if (!result.Table) {\n            throw new WebinyError(`No table provided for entity ${this.entity.name}.`);\n        } else if (!result.Key) {\n            throw new WebinyError(`No key provided for entity ${this.entity.name}.`);\n        }\n        return result as unknown as IEntityReadBatchBuilderGetResponse;\n    }\n}\n\nexport const createEntityReadBatchBuilder = (\n    entity: ToolboxEntity | Entity\n): IEntityReadBatchBuilder => {\n    return new EntityReadBatchBuilder(entity);\n};\n"],"names":["EntityReadBatchBuilder","entity","getEntity","item","result","WebinyError","createEntityReadBatchBuilder"],"mappings":";;AAWO,MAAMA;IAGT,YAAmBC,MAAoB,CAAE;QACrC,IAAI,CAAC,MAAM,GAAGC,UAAUD;IAC5B;IAEO,IAAIE,IAAyB,EAAsC;QACtE,MAAMC,SAAS,IAAI,CAAC,MAAM,CAAC,QAAQ,CAACD;QACpC,IAAKC,OAAO,KAAK,EAEV;YAAA,IAAI,CAACA,OAAO,GAAG,EAClB,MAAM,IAAIC,YAAY,CAAC,2BAA2B,EAAE,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;QAC3E,OAHI,MAAM,IAAIA,YAAY,CAAC,6BAA6B,EAAE,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;QAI7E,OAAOD;IACX;AACJ;AAEO,MAAME,+BAA+B,CACxCL,SAEO,IAAID,uBAAuBC"}

package/utils/entity/EntityWriteBatch.d.ts

@@ -0,0 +1,23 @@
+import type { BatchWriteItem, BatchWriteResult, IDeleteBatchItem, IPutBatchItem } from "../../utils/batch/types.js";
+import type { IEntityWriteBatch } from "./types.js";
+import type { ITableWriteBatch } from "../../utils/table/types.js";
+import type { EntityOption } from "./getEntity.js";
+import type { GenericRecord } from "@webiny/api/types.js";
+export interface IEntityWriteBatchParams<T = GenericRecord> {
+    entity: EntityOption;
+    put?: IPutBatchItem<T>[];
+    delete?: IDeleteBatchItem[];
+}
+export declare class EntityWriteBatch<T> implements IEntityWriteBatch<T> {
+    private readonly entity;
+    private readonly _items;
+    private readonly builder;
+    get total(): number;
+    get items(): BatchWriteItem[];
+    constructor(params: IEntityWriteBatchParams);
+    put(item: IPutBatchItem<T>): void;
+    delete(item: IDeleteBatchItem): void;
+    combine(items: BatchWriteItem[]): ITableWriteBatch;
+    execute(): Promise<BatchWriteResult>;
+}
+export declare const createEntityWriteBatch: (params: IEntityWriteBatchParams) => IEntityWriteBatch;

package/utils/entity/EntityWriteBatch.js

@@ -0,0 +1,44 @@
+import { batchWriteAll } from "../batch/batchWrite.js";
+import { createTableWriteBatch } from "../table/TableWriteBatch.js";
+import { createEntityWriteBatchBuilder } from "./EntityWriteBatchBuilder.js";
+import { getEntity } from "./getEntity.js";
+class EntityWriteBatch {
+    get total() {
+        return this._items.length;
+    }
+    get items() {
+        return Array.from(this._items);
+    }
+    constructor(params){
+        this._items = [];
+        this.entity = getEntity(params.entity);
+        this.builder = createEntityWriteBatchBuilder(this.entity);
+        for (const item of params.put || [])this.put(item);
+        for (const item of params.delete || [])this.delete(item);
+    }
+    put(item) {
+        this._items.push(this.builder.put(item));
+    }
+    delete(item) {
+        this._items.push(this.builder.delete(item));
+    }
+    combine(items) {
+        return createTableWriteBatch({
+            table: this.entity.table,
+            items: this._items.concat(items)
+        });
+    }
+    async execute() {
+        if (0 === this._items.length) return [];
+        const items = Array.from(this._items);
+        this._items.length = 0;
+        return await batchWriteAll({
+            items,
+            table: this.entity.table
+        });
+    }
+}
+const createEntityWriteBatch = (params)=>new EntityWriteBatch(params);
+export { EntityWriteBatch, createEntityWriteBatch };
+
+//# sourceMappingURL=EntityWriteBatch.js.map

package/utils/entity/EntityWriteBatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils/entity/EntityWriteBatch.js","sources":["../../../src/utils/entity/EntityWriteBatch.ts"],"sourcesContent":["import type { Entity as ToolboxEntity, TableDef } from \"~/toolbox.js\";\nimport { batchWriteAll } from \"~/utils/batch/batchWrite.js\";\nimport type {\n    BatchWriteItem,\n    BatchWriteResult,\n    IDeleteBatchItem,\n    IPutBatchItem\n} from \"~/utils/batch/types.js\";\nimport type { IEntityWriteBatch, IEntityWriteBatchBuilder } from \"./types.js\";\nimport type { ITableWriteBatch } from \"~/utils/table/types.js\";\nimport { createTableWriteBatch } from \"~/utils/table/TableWriteBatch.js\";\nimport { createEntityWriteBatchBuilder } from \"./EntityWriteBatchBuilder.js\";\nimport type { EntityOption } from \"./getEntity.js\";\nimport { getEntity } from \"./getEntity.js\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\n\nexport interface IEntityWriteBatchParams<T = GenericRecord> {\n    entity: EntityOption;\n    put?: IPutBatchItem<T>[];\n    delete?: IDeleteBatchItem[];\n}\n\nexport class EntityWriteBatch<T> implements IEntityWriteBatch<T> {\n    private readonly entity: ToolboxEntity;\n    private readonly _items: BatchWriteItem[] = [];\n    private readonly builder: IEntityWriteBatchBuilder;\n\n    public get total(): number {\n        return this._items.length;\n    }\n\n    public get items(): BatchWriteItem[] {\n        return Array.from(this._items);\n    }\n\n    public constructor(params: IEntityWriteBatchParams) {\n        this.entity = getEntity(params.entity);\n        this.builder = createEntityWriteBatchBuilder(this.entity);\n        for (const item of params.put || []) {\n            this.put(item);\n        }\n        for (const item of params.delete || []) {\n            this.delete(item);\n        }\n    }\n\n    public put(item: IPutBatchItem<T>): void {\n        this._items.push(this.builder.put(item));\n    }\n\n    public delete(item: IDeleteBatchItem): void {\n        this._items.push(this.builder.delete(item));\n    }\n\n    public combine(items: BatchWriteItem[]): ITableWriteBatch {\n        return createTableWriteBatch({\n            table: this.entity!.table as TableDef,\n            items: this._items.concat(items)\n        });\n    }\n\n    public async execute(): Promise<BatchWriteResult> {\n        if (this._items.length === 0) {\n            return [];\n        }\n        const items = Array.from(this._items);\n        this._items.length = 0;\n        return await batchWriteAll({\n            items,\n            table: this.entity.table\n        });\n    }\n}\n\nexport const createEntityWriteBatch = (params: IEntityWriteBatchParams): IEntityWriteBatch => {\n    return new EntityWriteBatch(params);\n};\n"],"names":["EntityWriteBatch","Array","params","getEntity","createEntityWriteBatchBuilder","item","items","createTableWriteBatch","batchWriteAll","createEntityWriteBatch"],"mappings":";;;;AAsBO,MAAMA;IAKT,IAAW,QAAgB;QACvB,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM;IAC7B;IAEA,IAAW,QAA0B;QACjC,OAAOC,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM;IACjC;IAEA,YAAmBC,MAA+B,CAAE;aAXnC,MAAM,GAAqB,EAAE;QAY1C,IAAI,CAAC,MAAM,GAAGC,UAAUD,OAAO,MAAM;QACrC,IAAI,CAAC,OAAO,GAAGE,8BAA8B,IAAI,CAAC,MAAM;QACxD,KAAK,MAAMC,QAAQH,OAAO,GAAG,IAAI,EAAE,CAC/B,IAAI,CAAC,GAAG,CAACG;QAEb,KAAK,MAAMA,QAAQH,OAAO,MAAM,IAAI,EAAE,CAClC,IAAI,CAAC,MAAM,CAACG;IAEpB;IAEO,IAAIA,IAAsB,EAAQ;QACrC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAACA;IACtC;IAEO,OAAOA,IAAsB,EAAQ;QACxC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAACA;IACzC;IAEO,QAAQC,KAAuB,EAAoB;QACtD,OAAOC,sBAAsB;YACzB,OAAO,IAAI,CAAC,MAAM,CAAE,KAAK;YACzB,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,CAACD;QAC9B;IACJ;IAEA,MAAa,UAAqC;QAC9C,IAAI,AAAuB,MAAvB,IAAI,CAAC,MAAM,CAAC,MAAM,EAClB,OAAO,EAAE;QAEb,MAAMA,QAAQL,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM;QACpC,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG;QACrB,OAAO,MAAMO,cAAc;YACvBF;YACA,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK;QAC5B;IACJ;AACJ;AAEO,MAAMG,yBAAyB,CAACP,SAC5B,IAAIF,iBAAiBE"}

package/utils/entity/EntityWriteBatchBuilder.d.ts

@@ -0,0 +1,11 @@
+import type { Entity } from "../../toolbox.js";
+import type { BatchWriteItem, IDeleteBatchItem, IPutBatchItem } from "../../utils/batch/types.js";
+import type { IEntityWriteBatchBuilder } from "./types.js";
+import type { EntityOption } from "./getEntity.js";
+export declare class EntityWriteBatchBuilder implements IEntityWriteBatchBuilder {
+    private readonly entity;
+    constructor(entity: EntityOption);
+    put<T extends Record<string, any>>(item: IPutBatchItem<T>): BatchWriteItem;
+    delete(item: IDeleteBatchItem): BatchWriteItem;
+}
+export declare const createEntityWriteBatchBuilder: (entity: Entity) => IEntityWriteBatchBuilder;

package/utils/entity/EntityWriteBatchBuilder.js

@@ -0,0 +1,19 @@
+import { getEntity } from "./getEntity.js";
+class EntityWriteBatchBuilder {
+    constructor(entity){
+        this.entity = getEntity(entity);
+    }
+    put(item) {
+        return this.entity.putBatch(item, {
+            execute: true,
+            strictSchemaCheck: false
+        });
+    }
+    delete(item) {
+        return this.entity.deleteBatch(item);
+    }
+}
+const createEntityWriteBatchBuilder = (entity)=>new EntityWriteBatchBuilder(entity);
+export { EntityWriteBatchBuilder, createEntityWriteBatchBuilder };
+
+//# sourceMappingURL=EntityWriteBatchBuilder.js.map

package/utils/entity/EntityWriteBatchBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils/entity/EntityWriteBatchBuilder.js","sources":["../../../src/utils/entity/EntityWriteBatchBuilder.ts"],"sourcesContent":["import type { Entity } from \"~/toolbox.js\";\nimport type { BatchWriteItem, IDeleteBatchItem, IPutBatchItem } from \"~/utils/batch/types.js\";\nimport type { IEntityWriteBatchBuilder } from \"./types.js\";\nimport type { EntityOption } from \"./getEntity.js\";\nimport { getEntity } from \"./getEntity.js\";\n\nexport class EntityWriteBatchBuilder implements IEntityWriteBatchBuilder {\n    private readonly entity: Entity;\n\n    public constructor(entity: EntityOption) {\n        this.entity = getEntity(entity);\n    }\n\n    public put<T extends Record<string, any>>(item: IPutBatchItem<T>): BatchWriteItem {\n        return this.entity.putBatch(item, {\n            execute: true,\n            strictSchemaCheck: false\n        });\n    }\n\n    public delete(item: IDeleteBatchItem): BatchWriteItem {\n        return this.entity.deleteBatch(item);\n    }\n}\n\nexport const createEntityWriteBatchBuilder = (entity: Entity): IEntityWriteBatchBuilder => {\n    return new EntityWriteBatchBuilder(entity);\n};\n"],"names":["EntityWriteBatchBuilder","entity","getEntity","item","createEntityWriteBatchBuilder"],"mappings":";AAMO,MAAMA;IAGT,YAAmBC,MAAoB,CAAE;QACrC,IAAI,CAAC,MAAM,GAAGC,UAAUD;IAC5B;IAEO,IAAmCE,IAAsB,EAAkB;QAC9E,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,CAACA,MAAM;YAC9B,SAAS;YACT,mBAAmB;QACvB;IACJ;IAEO,OAAOA,IAAsB,EAAkB;QAClD,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAACA;IACnC;AACJ;AAEO,MAAMC,gCAAgC,CAACH,SACnC,IAAID,wBAAwBC"}

package/utils/entity/getEntity.d.ts

@@ -0,0 +1,4 @@
+import { Entity as ToolboxEntity } from "../../toolbox.js";
+import type { Entity } from "./Entity.js";
+export type EntityOption = ToolboxEntity | Entity;
+export declare const getEntity: (entity: EntityOption) => ToolboxEntity;

package/utils/entity/getEntity.js

@@ -0,0 +1,11 @@
+import { Entity } from "../../toolbox.js";
+const getEntity = (entity)=>{
+    const result = entity instanceof Entity ? entity : entity.entity;
+    if (result.name) {
+        if (!result.table) throw new Error(`No table provided for entity ${result.name}.`);
+    } else throw new Error("No name provided for entity.");
+    return result;
+};
+export { getEntity };
+
+//# sourceMappingURL=getEntity.js.map

package/utils/entity/getEntity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils/entity/getEntity.js","sources":["../../../src/utils/entity/getEntity.ts"],"sourcesContent":["import { Entity as ToolboxEntity } from \"~/toolbox.js\";\nimport type { Entity } from \"./Entity.js\";\n\nexport type EntityOption = ToolboxEntity | Entity;\n\nexport const getEntity = (entity: EntityOption): ToolboxEntity => {\n    const result = entity instanceof ToolboxEntity ? entity : entity.entity;\n    if (!result.name) {\n        throw new Error(`No name provided for entity.`);\n    } else if (!result.table) {\n        throw new Error(`No table provided for entity ${result.name}.`);\n    }\n    return result;\n};\n"],"names":["getEntity","entity","result","ToolboxEntity","Error"],"mappings":";AAKO,MAAMA,YAAY,CAACC;IACtB,MAAMC,SAASD,kBAAkBE,SAAgBF,SAASA,OAAO,MAAM;IACvE,IAAKC,OAAO,IAAI,EAET;QAAA,IAAI,CAACA,OAAO,KAAK,EACpB,MAAM,IAAIE,MAAM,CAAC,6BAA6B,EAAEF,OAAO,IAAI,CAAC,CAAC,CAAC;IAClE,OAHI,MAAM,IAAIE,MAAM;IAIpB,OAAOF;AACX"}

package/utils/entity/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./Entity.js";
+export * from "./EntityReadBatch.js";
+export * from "./EntityReadBatchBuilder.js";
+export * from "./EntityWriteBatch.js";
+export * from "./EntityWriteBatchBuilder.js";
+export * from "./getEntity.js";
+export * from "./types.js";

package/utils/entity/index.js

@@ -0,0 +1,7 @@
+export * from "./Entity.js";
+export * from "./EntityReadBatch.js";
+export * from "./EntityReadBatchBuilder.js";
+export * from "./EntityWriteBatch.js";
+export * from "./EntityWriteBatchBuilder.js";
+export * from "./getEntity.js";
+export * from "./types.js";

package/utils/entity/types.d.ts

@@ -0,0 +1,75 @@
+import type { Entity as BaseEntity } from "dynamodb-toolbox";
+import type { BatchWriteItem, BatchWriteResult, IDeleteBatchItem, IPutBatchItem } from "../../utils/batch/types.js";
+import type { GenericRecord } from "@webiny/api/types.js";
+import type { TableDef } from "../../toolbox.js";
+import type { ITableWriteBatch } from "../../utils/table/types.js";
+import type { IPutParamsItem, put } from "../../utils/put.js";
+import { queryAll, queryAllClean, type QueryAllParams, queryOne, queryOneClean, type QueryOneParams } from "../../utils/query.js";
+import type { get, getClean, GetRecordParamsKeys } from "../../utils/get.js";
+import type { deleteItem, IDeleteItemKeys } from "../../utils/delete.js";
+import type { batchReadAll, BatchReadItem } from "../../utils/batch/batchRead.js";
+import type { IEntityWriteBatchParams } from "./EntityWriteBatch.js";
+import type { IEntityReadBatchParams } from "./EntityReadBatch.js";
+import { queryPerPage } from "../../utils/index.js";
+export type IEntityQueryOneParams = Omit<QueryOneParams, "entity">;
+export type IEntityQueryAllParams = Omit<QueryAllParams, "entity">;
+export type IEntityQueryPerPageParams = Omit<QueryAllParams, "entity">;
+export interface IEntityCreateEntityWriterParams<T = GenericRecord> extends Omit<IEntityWriteBatchParams<T>, "entity"> {
+}
+export interface IEntityCreateEntityReaderParams extends Omit<IEntityReadBatchParams, "entity"> {
+}
+export type IEntityPutResult = ReturnType<typeof put>;
+export type IEntityGetResult<T> = ReturnType<typeof get<T>>;
+export type IEntityGetCleanResult<T> = ReturnType<typeof getClean<T>>;
+export type IEntityDeleteResult = ReturnType<typeof deleteItem>;
+export type IEntityQueryOneResult<T> = ReturnType<typeof queryOne<T>>;
+export type IEntityQueryOneCleanResult<T> = ReturnType<typeof queryOneClean<T>>;
+export type IEntityQueryAllResult<T> = ReturnType<typeof queryAll<T>>;
+export type IEntityQueryAllCleanResult<T> = ReturnType<typeof queryAllClean<T>>;
+export type IEntityQueryPerPageResult<T> = ReturnType<typeof queryPerPage<T>>;
+export interface IEntity<T extends GenericRecord = GenericRecord> {
+    readonly entity: BaseEntity;
+    readonly name: string;
+    readonly table: TableDef;
+    createEntityReader(params?: IEntityCreateEntityReaderParams): IEntityReadBatch<T>;
+    createEntityWriter(params?: IEntityCreateEntityWriterParams<T>): IEntityWriteBatch<T>;
+    createTableWriter(): ITableWriteBatch;
+    put(item: IPutParamsItem<T>): IEntityPutResult;
+    get<R extends T = T>(keys: GetRecordParamsKeys): IEntityGetResult<R>;
+    getClean<R extends T = T>(keys: GetRecordParamsKeys): IEntityGetCleanResult<R>;
+    delete(keys: IDeleteItemKeys): IEntityDeleteResult;
+    queryOne<R extends T = T>(params: IEntityQueryOneParams): IEntityQueryOneResult<R>;
+    queryOneClean<R extends T = T>(params: IEntityQueryOneParams): IEntityQueryOneCleanResult<R>;
+    queryAll<R extends T = T>(params: IEntityQueryAllParams): IEntityQueryAllResult<R>;
+    queryAllClean<R extends T = T>(params: IEntityQueryAllParams): IEntityQueryAllCleanResult<R>;
+    queryPerPage<R extends T = T>(params: IEntityQueryPerPageParams): IEntityQueryPerPageResult<R>;
+}
+export interface IEntityWriteBatchBuilder {
+    put<T extends Record<string, any>>(item: IPutBatchItem<T>): BatchWriteItem;
+    delete(item: IDeleteBatchItem): BatchWriteItem;
+}
+export interface IEntityWriteBatch<T = GenericRecord> {
+    readonly total: number;
+    readonly items: BatchWriteItem[];
+    put(item: IPutBatchItem<T>): void;
+    delete(item: IDeleteBatchItem): void;
+    execute(): Promise<BatchWriteResult>;
+    combine(items: BatchWriteItem[]): ITableWriteBatch;
+}
+export interface IEntityReadBatchKey {
+    PK: string;
+    SK: string;
+}
+export interface IEntityReadBatch<T = GenericRecord> {
+    readonly total: number;
+    readonly items: BatchReadItem[];
+    get(input: IEntityReadBatchKey | IEntityReadBatchKey[]): void;
+    execute(): ReturnType<typeof batchReadAll<T>>;
+}
+export interface IEntityReadBatchBuilderGetResponse {
+    Table: TableDef;
+    Key: IEntityReadBatchKey;
+}
+export interface IEntityReadBatchBuilder {
+    get(item: IEntityReadBatchKey): IEntityReadBatchBuilderGetResponse;
+}

package/utils/get.d.ts

@@ -1,10 +1,11 @@
-import { Entity } from "dynamodb-toolbox";
+import type { Entity } from "../toolbox.js";
+export interface GetRecordParamsKeys {
+    PK: string;
+    SK: string;
+}
 export interface GetRecordParams {
-    entity: Entity<any>;
-    keys: {
-        PK: string;
-        SK: string;
-    };
+    entity: Entity;
+    keys: GetRecordParamsKeys;
 }
 /**
  * Gets a single record from the DynamoDB table.
@@ -15,3 +16,4 @@ export interface GetRecordParams {
  * @throws
  */
 export declare const get: <T>(params: GetRecordParams) => Promise<T | null>;
+export declare const getClean: <T>(params: GetRecordParams) => Promise<T | null>;

package/utils/get.js

@@ -1,30 +1,17 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.get = void 0;
-
-/**
- * Gets a single record from the DynamoDB table.
- * Returns either record or null.
- *
- * Be aware to wrap in try/catch to avoid the error killing your app.
- *
- * @throws
- */
-const get = async params => {
-  const {
-    entity,
-    keys
-  } = params;
-  const result = await entity.get(keys);
-
-  if (!result || !result.Item) {
-    return null;
-  }
-
-  return result.Item;
+import { cleanupItem } from "./cleanup.js";
+const get = async (params)=>{
+    const { entity, keys } = params;
+    const result = await entity.get(keys, {
+        execute: true
+    });
+    if (!result?.Item) return null;
+    return result.Item;
+};
+const getClean = async (params)=>{
+    const result = await get(params);
+    if (!result) return null;
+    return cleanupItem(params.entity, result);
 };
+export { get, getClean };
 
-exports.get = get;
+//# sourceMappingURL=get.js.map

package/utils/get.js.map

@@ -1 +1 @@
-{"version":3,"names":["get","params","entity","keys","result","Item"],"sources":["get.ts"],"sourcesContent":["import { Entity } from \"dynamodb-toolbox\";\n\nexport interface GetRecordParams {\n    entity: Entity<any>;\n    keys: {\n        PK: string;\n        SK: string;\n    };\n}\n\n/**\n * Gets a single record from the DynamoDB table.\n * Returns either record or null.\n *\n * Be aware to wrap in try/catch to avoid the error killing your app.\n *\n * @throws\n */\nexport const get = async <T>(params: GetRecordParams): Promise<T | null> => {\n    const { entity, keys } = params;\n\n    const result = await entity.get(keys);\n\n    if (!result || !result.Item) {\n        return null;\n    }\n    return result.Item;\n};\n"],"mappings":";;;;;;;AAUA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMA,GAAG,GAAG,MAAUC,MAAV,IAAyD;EACxE,MAAM;IAAEC,MAAF;IAAUC;EAAV,IAAmBF,MAAzB;EAEA,MAAMG,MAAM,GAAG,MAAMF,MAAM,CAACF,GAAP,CAAWG,IAAX,CAArB;;EAEA,IAAI,CAACC,MAAD,IAAW,CAACA,MAAM,CAACC,IAAvB,EAA6B;IACzB,OAAO,IAAP;EACH;;EACD,OAAOD,MAAM,CAACC,IAAd;AACH,CATM"}
+{"version":3,"file":"utils/get.js","sources":["../../src/utils/get.ts"],"sourcesContent":["import type { Entity } from \"~/toolbox.js\";\nimport { cleanupItem } from \"~/utils/cleanup.js\";\n\nexport interface GetRecordParamsKeys {\n    PK: string;\n    SK: string;\n}\n\nexport interface GetRecordParams {\n    entity: Entity;\n    keys: GetRecordParamsKeys;\n}\n\n/**\n * Gets a single record from the DynamoDB table.\n * Returns either record or null.\n *\n * Be aware to wrap in try/catch to avoid the error killing your app.\n *\n * @throws\n */\nexport const get = async <T>(params: GetRecordParams): Promise<T | null> => {\n    const { entity, keys } = params;\n\n    const result = await entity.get(keys, {\n        execute: true\n    });\n\n    if (!result?.Item) {\n        return null;\n    }\n    return result.Item as T;\n};\n\nexport const getClean = async <T>(params: GetRecordParams): Promise<T | null> => {\n    const result = await get<T>(params);\n    if (!result) {\n        return null;\n    }\n    return cleanupItem<T>(params.entity, result);\n};\n"],"names":["get","params","entity","keys","result","getClean","cleanupItem"],"mappings":";AAqBO,MAAMA,MAAM,OAAUC;IACzB,MAAM,EAAEC,MAAM,EAAEC,IAAI,EAAE,GAAGF;IAEzB,MAAMG,SAAS,MAAMF,OAAO,GAAG,CAACC,MAAM;QAClC,SAAS;IACb;IAEA,IAAI,CAACC,QAAQ,MACT,OAAO;IAEX,OAAOA,OAAO,IAAI;AACtB;AAEO,MAAMC,WAAW,OAAUJ;IAC9B,MAAMG,SAAS,MAAMJ,IAAOC;IAC5B,IAAI,CAACG,QACD,OAAO;IAEX,OAAOE,YAAeL,OAAO,MAAM,EAAEG;AACzC"}

package/utils/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./cleanup.js";
+export * from "./createEntity.js";
+export * from "./createTable.js";
+export { decodeCursor, encodeCursor } from "./cursor.js";
+export * from "./get.js";
+export * from "./delete.js";
+export * from "./put.js";
+export * from "./query.js";
+export * from "./scan.js";
+export * from "./sort.js";
+export * from "./batch/index.js";
+export * from "./entity/index.js";
+export * from "./table/index.js";

package/utils/index.js

@@ -0,0 +1,13 @@
+export * from "./cleanup.js";
+export * from "./createEntity.js";
+export * from "./createTable.js";
+export * from "./get.js";
+export * from "./delete.js";
+export * from "./put.js";
+export * from "./query.js";
+export * from "./scan.js";
+export * from "./sort.js";
+export * from "./batch/index.js";
+export * from "./entity/index.js";
+export * from "./table/index.js";
+export { decodeCursor, encodeCursor } from "./cursor.js";

package/utils/put.d.ts

@@ -0,0 +1,12 @@
+import type { Entity } from "../toolbox.js";
+import type { GenericRecord } from "@webiny/api/types.js";
+export type IPutParamsItem<T extends GenericRecord = GenericRecord> = {
+    PK: string;
+    SK: string;
+    [key: string]: any;
+} & T;
+export interface IPutParams<T extends GenericRecord = GenericRecord> {
+    entity: Entity;
+    item: IPutParamsItem<T>;
+}
+export declare const put: <T extends GenericRecord = GenericRecord>(params: IPutParams<T>) => Promise<import("@aws-sdk/lib-dynamodb").PutCommandOutput>;