@lafken/dynamo 0.10.1

package/lib/service/query-builder/batch-write/batch-write.types.d.ts

@@ -0,0 +1,9 @@
+import type { BatchWriteItemCommandInput } from '@aws-sdk/client-dynamodb';
+import type { ClassResource } from '@lafken/common';
+import type { QueryBuilderProps } from '../base/base.types';
+import type { Item } from '../query-builder.types';
+export interface BatchWriteBuilderProps<E extends ClassResource> extends QueryBuilderProps<E> {
+    items: Partial<Item<E>>[];
+    maxAttempt?: number;
+    generateBatchCommand: (items: Partial<Item<E>>[]) => BatchWriteItemCommandInput;
+}

package/lib/service/query-builder/batch-write/batch-write.types.js

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

package/lib/service/query-builder/bulk-create/bulk-create.d.ts

@@ -0,0 +1,6 @@
+import type { ClassResource } from '@lafken/common';
+import { BatchWriteBuilder } from '../batch-write/batch-write';
+import type { BulkCreateBuilderProps } from './bulk-create.types';
+export declare class BulkCreateBuilder<E extends ClassResource> extends BatchWriteBuilder<E> {
+    constructor(queryOptions: BulkCreateBuilderProps<E>);
+}

package/lib/service/query-builder/bulk-create/bulk-create.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BulkCreateBuilder = void 0;
+const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
+const batch_write_1 = require("../batch-write/batch-write");
+class BulkCreateBuilder extends batch_write_1.BatchWriteBuilder {
+    constructor(queryOptions) {
+        super({
+            ...queryOptions,
+            generateBatchCommand: (items) => {
+                return {
+                    RequestItems: {
+                        [queryOptions.modelProps.name]: items.map((item) => {
+                            return {
+                                PutRequest: {
+                                    Item: (0, util_dynamodb_1.marshall)(item),
+                                },
+                            };
+                        }),
+                    },
+                };
+            },
+        });
+    }
+}
+exports.BulkCreateBuilder = BulkCreateBuilder;

package/lib/service/query-builder/bulk-create/bulk-create.types.d.ts

@@ -0,0 +1,4 @@
+import type { ClassResource } from '@lafken/common';
+import type { BatchWriteBuilderProps } from '../batch-write/batch-write.types';
+export interface BulkCreateBuilderProps<E extends ClassResource> extends Omit<BatchWriteBuilderProps<E>, 'generateBatchCommand'> {
+}

package/lib/service/query-builder/bulk-create/bulk-create.types.js

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

package/lib/service/query-builder/bulk-delete/bulk-delete.d.ts

@@ -0,0 +1,6 @@
+import type { ClassResource } from '@lafken/common';
+import { BatchWriteBuilder } from '../batch-write/batch-write';
+import type { BulkDeleteBuilderProps } from './bulk-delete.types';
+export declare class BulkDeleteBuilder<E extends ClassResource> extends BatchWriteBuilder<E> {
+    constructor(queryOptions: BulkDeleteBuilderProps<E>);
+}

package/lib/service/query-builder/bulk-delete/bulk-delete.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BulkDeleteBuilder = void 0;
+const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
+const batch_write_1 = require("../batch-write/batch-write");
+class BulkDeleteBuilder extends batch_write_1.BatchWriteBuilder {
+    constructor(queryOptions) {
+        super({
+            ...queryOptions,
+            items: queryOptions.keys,
+            generateBatchCommand: (items) => {
+                return {
+                    RequestItems: {
+                        [queryOptions.modelProps.name]: items.map((item) => {
+                            return {
+                                DeleteRequest: {
+                                    Key: (0, util_dynamodb_1.marshall)(item),
+                                },
+                            };
+                        }),
+                    },
+                };
+            },
+        });
+    }
+}
+exports.BulkDeleteBuilder = BulkDeleteBuilder;

package/lib/service/query-builder/bulk-delete/bulk-delete.types.d.ts

@@ -0,0 +1,7 @@
+import type { ClassResource } from '@lafken/common';
+import type { TablePartition } from '../../../main/table';
+import type { BatchWriteBuilderProps } from '../batch-write/batch-write.types';
+import type { Item } from '../query-builder.types';
+export interface BulkDeleteBuilderProps<E extends ClassResource> extends Omit<BatchWriteBuilderProps<E>, 'generateBatchCommand' | 'items'> {
+    keys: TablePartition<Item<E>>[];
+}

package/lib/service/query-builder/bulk-delete/bulk-delete.types.js

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

package/lib/service/query-builder/create/create.d.ts

@@ -0,0 +1,6 @@
+import type { ClassResource } from '@lafken/common';
+import { UpsertBuilder } from '../upsert/upsert';
+import type { CreateBuilderProps } from './create.types';
+export declare class CreateBuilder<E extends ClassResource> extends UpsertBuilder<E> {
+    constructor(queryOptions: CreateBuilderProps<E>);
+}

package/lib/service/query-builder/create/create.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateBuilder = void 0;
+const upsert_1 = require("../upsert/upsert");
+class CreateBuilder extends upsert_1.UpsertBuilder {
+    constructor(queryOptions) {
+        const notExist = {
+            notExist: true,
+        };
+        const filter = {
+            [queryOptions.partitionKey]: notExist,
+            ...(queryOptions.sortKey ? { [queryOptions.sortKey]: notExist } : {}),
+        };
+        super({
+            ...queryOptions,
+            inputProps: {
+                condition: filter,
+            },
+        });
+    }
+}
+exports.CreateBuilder = CreateBuilder;

package/lib/service/query-builder/create/create.types.d.ts

@@ -0,0 +1,6 @@
+import type { ClassResource } from '@lafken/common';
+import type { QueryBuilderProps } from '../base/base.types';
+import type { Item } from '../query-builder.types';
+export interface CreateBuilderProps<E extends ClassResource> extends QueryBuilderProps<E> {
+    item: Item<E>;
+}

package/lib/service/query-builder/create/create.types.js

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

package/lib/service/query-builder/delete/delete.d.ts

@@ -0,0 +1,13 @@
+import { type DeleteItemCommandInput } from '@aws-sdk/client-dynamodb';
+import type { ClassResource } from '@lafken/common';
+import { QueryBuilderBase } from '../base/base';
+import type { DeleteBuilderProps } from './delete.types';
+export declare class DeleteBuilder<E extends ClassResource> extends QueryBuilderBase<E> {
+    private queryOptions;
+    protected command: DeleteItemCommandInput;
+    constructor(queryOptions: DeleteBuilderProps<E>);
+    getCommand(): DeleteItemCommandInput;
+    then<T>(resolve: (value: boolean) => T, reject: (reason: any) => T): Promise<T>;
+    private exec;
+    protected prepare(): void;
+}

package/lib/service/query-builder/delete/delete.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteBuilder = void 0;
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
+const base_1 = require("../base/base");
+class DeleteBuilder extends base_1.QueryBuilderBase {
+    queryOptions;
+    command;
+    constructor(queryOptions) {
+        super(queryOptions);
+        this.queryOptions = queryOptions;
+        this.prepare();
+    }
+    getCommand() {
+        return this.command;
+    }
+    then(resolve, reject) {
+        return this.exec().then(resolve, reject);
+    }
+    async exec() {
+        const command = new client_dynamodb_1.DeleteItemCommand(this.command);
+        await this.queryOptions.client.send(command);
+        return true;
+    }
+    prepare() {
+        this.command = {
+            TableName: this.queryOptions.modelProps.name,
+            Key: (0, util_dynamodb_1.marshall)(this.queryOptions.key),
+        };
+    }
+}
+exports.DeleteBuilder = DeleteBuilder;

package/lib/service/query-builder/delete/delete.types.d.ts

@@ -0,0 +1,7 @@
+import type { ClassResource } from '@lafken/common';
+import type { TablePartition } from '../../../main/table';
+import type { QueryBuilderProps } from '../base/base.types';
+import type { Item } from '../query-builder.types';
+export interface DeleteBuilderProps<E extends ClassResource> extends QueryBuilderProps<E> {
+    key: TablePartition<Item<E>>;
+}

package/lib/service/query-builder/delete/delete.types.js

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

package/lib/service/query-builder/dynamo-index/dynamo-index.d.ts

@@ -0,0 +1,15 @@
+import type { DynamoIndex, LocalIndex } from '../../../main';
+import type { QueryProps } from '../query-builder.types';
+import type { GlobalIndexProperty } from './dynamo-index.types';
+export declare class DynamoIndexes {
+    private partitionKey;
+    private sortKey?;
+    private localIndexes;
+    private globalIndexes;
+    private indexByName;
+    constructor(indexes: DynamoIndex<any>[], partitionKey: string, sortKey?: string | undefined);
+    getIndex(props: QueryProps<any>): LocalIndex<any> | GlobalIndexProperty | undefined;
+    private getLocalIndex;
+    private getGlobalIndex;
+    private compareIndexAttributes;
+}

package/lib/service/query-builder/dynamo-index/dynamo-index.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamoIndexes = void 0;
+class DynamoIndexes {
+    partitionKey;
+    sortKey;
+    localIndexes = [];
+    globalIndexes = [];
+    indexByName = {};
+    constructor(indexes, partitionKey, sortKey) {
+        this.partitionKey = partitionKey;
+        this.sortKey = sortKey;
+        for (const index of indexes) {
+            if (index.type === 'local') {
+                this.indexByName[index.name] = index;
+                this.localIndexes.push(index);
+                continue;
+            }
+            const globalIndex = {
+                ...index,
+                type: 'global',
+                partitionKey: Array.isArray(index.partitionKey)
+                    ? new Set([...index.partitionKey])
+                    : new Set([index.partitionKey]),
+                sortKey: !index.sortKey
+                    ? new Set()
+                    : Array.isArray(index.sortKey)
+                        ? new Set([...index.sortKey])
+                        : new Set([index.sortKey]),
+            };
+            this.indexByName[index.name] = globalIndex;
+            this.globalIndexes.push(globalIndex);
+        }
+    }
+    getIndex(props) {
+        const { keyCondition: { partition, sort }, indexName, } = props;
+        if (indexName) {
+            const index = this.indexByName[indexName];
+            if (!index) {
+                throw new Error(`the index "${indexName}" does not exist`);
+            }
+            return index;
+        }
+        const partitionKeys = Object.keys(partition);
+        const sortKeys = Object.keys(sort || {});
+        if (partitionKeys.length > 1 || sortKeys.length > 1) {
+            return this.getGlobalIndex(new Set(partitionKeys), new Set(sortKeys));
+        }
+        if (this.partitionKey === partitionKeys[0] && this.sortKey !== sortKeys[0]) {
+            const index = this.getLocalIndex(sortKeys[0]);
+            if (index) {
+                return index;
+            }
+        }
+        if (this.partitionKey === partitionKeys[0] &&
+            (!this.sortKey || sortKeys.length === 0 || this.sortKey === sortKeys[0])) {
+            return;
+        }
+        return this.getGlobalIndex(new Set(partitionKeys), new Set(sortKeys));
+    }
+    getLocalIndex(sortKey) {
+        const index = this.localIndexes.find((index) => index.sortKey === sortKey);
+        return index;
+    }
+    getGlobalIndex(partitionKeys, sortKeys) {
+        const index = this.globalIndexes.find((index) => {
+            if (index.partitionKey.size !== partitionKeys.size) {
+                return false;
+            }
+            if (this.compareIndexAttributes(index.partitionKey, partitionKeys) &&
+                this.compareIndexAttributes(index.sortKey, sortKeys)) {
+                return true;
+            }
+            return false;
+        });
+        if (!index) {
+            throw new Error('no index found for the selected attributes');
+        }
+        return index;
+    }
+    compareIndexAttributes(indexKeys, queryKeys) {
+        for (const item of queryKeys) {
+            if (!indexKeys.has(item)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+exports.DynamoIndexes = DynamoIndexes;

package/lib/service/query-builder/dynamo-index/dynamo-index.types.d.ts

@@ -0,0 +1,5 @@
+import type { GlobalIndex } from '../../../main';
+export interface GlobalIndexProperty extends Omit<GlobalIndex<any>, 'partitionKey' | 'sortKey'> {
+    partitionKey: Set<string>;
+    sortKey: Set<string>;
+}

package/lib/service/query-builder/dynamo-index/dynamo-index.types.js

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

package/lib/service/query-builder/find/find.d.ts

@@ -0,0 +1,13 @@
+import { type QueryCommandInput } from '@aws-sdk/client-dynamodb';
+import type { ClassResource } from '@lafken/common';
+import { QueryBuilderBase } from '../base/base';
+import type { QueryResponse } from '../query-builder.types';
+import type { FindBuilderProps } from './find.types';
+export declare class FindBuilder<E extends ClassResource> extends QueryBuilderBase<E> {
+    protected queryOptions: FindBuilderProps<E>;
+    protected command: QueryCommandInput;
+    constructor(queryOptions: FindBuilderProps<E>);
+    getCommand(): QueryCommandInput;
+    protected find(): void;
+    protected runQuery(input: QueryCommandInput, data?: Partial<E[]>): Promise<QueryResponse<E>>;
+}

package/lib/service/query-builder/find/find.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindBuilder = void 0;
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
+const base_1 = require("../base/base");
+class FindBuilder extends base_1.QueryBuilderBase {
+    queryOptions;
+    command;
+    constructor(queryOptions) {
+        super(queryOptions);
+        this.queryOptions = queryOptions;
+        this.find();
+    }
+    getCommand() {
+        return this.command;
+    }
+    find() {
+        const { limit, cursor, keyCondition, filter, projection = 'ALL', sortDirection = 'asc', } = this.queryOptions.inputProps;
+        const index = this.queryOptions.indexes.getIndex(this.queryOptions.inputProps);
+        const keyConditionExpression = this.getKeyConditionExpression(keyCondition, index);
+        let filterExpression;
+        if (filter) {
+            const expression = this.getFilterExpression(filter || {});
+            filterExpression = expression;
+        }
+        this.command = {
+            TableName: this.queryOptions.modelProps.name,
+            IndexName: index?.name,
+            KeyConditionExpression: keyConditionExpression,
+            FilterExpression: filterExpression,
+            ExclusiveStartKey: cursor ? (0, util_dynamodb_1.marshall)(cursor) : undefined,
+            Limit: limit,
+            ScanIndexForward: sortDirection === 'asc',
+            ProjectionExpression: projection === 'ALL' ? undefined : projection.join(', '),
+            ...this.getAttributesAndNames(),
+        };
+    }
+    async runQuery(input, data = []) {
+        const command = new client_dynamodb_1.QueryCommand(input);
+        const { Items = [], LastEvaluatedKey } = await this.queryOptions.client.send(command);
+        const resultData = Items.map((item) => (0, util_dynamodb_1.unmarshall)(item));
+        if (input.Limit === 1) {
+            return {
+                data: [resultData[0]],
+                cursor: LastEvaluatedKey ? (0, util_dynamodb_1.unmarshall)(LastEvaluatedKey) : undefined,
+            };
+        }
+        const items = data.concat(resultData);
+        if (LastEvaluatedKey && (!input.Limit || items.length < input.Limit)) {
+            return this.runQuery({
+                ...input,
+                ExclusiveStartKey: LastEvaluatedKey,
+                Limit: input.Limit ? input.Limit - items.length : undefined,
+            }, items);
+        }
+        return {
+            data: items,
+            cursor: LastEvaluatedKey ? (0, util_dynamodb_1.unmarshall)(LastEvaluatedKey) : undefined,
+        };
+    }
+}
+exports.FindBuilder = FindBuilder;

package/lib/service/query-builder/find/find.types.d.ts

@@ -0,0 +1,8 @@
+import type { ClassResource } from '@lafken/common';
+import type { QueryBuilderProps } from '../base/base.types';
+import type { DynamoIndexes } from '../dynamo-index/dynamo-index';
+import type { QueryProps } from '../query-builder.types';
+export interface FindBuilderProps<E extends ClassResource> extends QueryBuilderProps<E> {
+    inputProps: QueryProps<E>;
+    indexes: DynamoIndexes;
+}

package/lib/service/query-builder/find/find.types.js

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

package/lib/service/query-builder/find-all/find-all.d.ts

@@ -0,0 +1,10 @@
+import type { ClassResource } from '@lafken/common';
+import { FindBuilder } from '../find/find';
+import type { FindBuilderProps } from '../find/find.types';
+import type { QueryResponse } from '../query-builder.types';
+export declare class FindAllBuilder<E extends ClassResource> extends FindBuilder<E> {
+    protected queryOptions: FindBuilderProps<E>;
+    constructor(queryOptions: FindBuilderProps<E>);
+    then<T>(resolve: (value: QueryResponse<E>) => T, reject: (reason: any) => T): Promise<T>;
+    private exec;
+}

package/lib/service/query-builder/find-all/find-all.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindAllBuilder = void 0;
+const find_1 = require("../find/find");
+class FindAllBuilder extends find_1.FindBuilder {
+    queryOptions;
+    constructor(queryOptions) {
+        super(queryOptions);
+        this.queryOptions = queryOptions;
+        this.find();
+    }
+    then(resolve, reject) {
+        return this.exec().then(resolve, reject);
+    }
+    async exec() {
+        return this.runQuery(this.command);
+    }
+}
+exports.FindAllBuilder = FindAllBuilder;

package/lib/service/query-builder/find-one/find-one.d.ts

@@ -0,0 +1,9 @@
+import type { ClassResource } from '@lafken/common';
+import { FindBuilder } from '../find/find';
+import type { FindBuilderProps } from '../find/find.types';
+export declare class FindOneBuilder<E extends ClassResource> extends FindBuilder<E> {
+    protected queryOptions: FindBuilderProps<E>;
+    constructor(queryOptions: FindBuilderProps<E>);
+    then<T>(resolve: (value: InstanceType<E> | undefined) => T, reject: (reason: any) => T): Promise<T>;
+    private exec;
+}

package/lib/service/query-builder/find-one/find-one.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindOneBuilder = void 0;
+const find_1 = require("../find/find");
+class FindOneBuilder extends find_1.FindBuilder {
+    queryOptions;
+    constructor(queryOptions) {
+        super(queryOptions);
+        this.queryOptions = queryOptions;
+        this.find();
+    }
+    then(resolve, reject) {
+        return this.exec().then(resolve, reject);
+    }
+    async exec() {
+        const { data } = await this.runQuery(this.command);
+        return data?.[0];
+    }
+}
+exports.FindOneBuilder = FindOneBuilder;

package/lib/service/query-builder/index.d.ts

@@ -0,0 +1 @@
+export * from './query-builder.types';

package/lib/service/query-builder/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./query-builder.types"), exports);