@lafken/dynamo 0.10.1

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

@@ -0,0 +1,243 @@
+import 'reflect-metadata';
+import type { ClassResource, DeepPartial, KeyOfClass, OnlyNumberString, OnlyOne } from '@lafken/common';
+import type { FieldsMetadata, PrimaryPartition, TablePartition, TablePayPerRequest, TableProvisioned } from '../../main/table';
+interface RequiredName {
+    name: string;
+}
+export type ModelMetadata<T extends Function> = (TableProvisioned<T> & RequiredName) | (TablePayPerRequest<T> & RequiredName);
+export type OperationExpression<E> = OnlyOne<{
+    lessThan: E;
+    lessOrEqualThan: E;
+    greaterThan: E;
+    greaterOrEqualThan: E;
+    between: [E, E];
+}>;
+export type InExpression<E extends string | number> = {
+    in: E[];
+};
+export type NullExpression = OnlyOne<{
+    exist: true;
+    notExist: true;
+}>;
+export type StringExpression = {
+    beginsWith: string;
+};
+export type StringFilterExpression = OnlyOne<{
+    contains: string;
+    notContains: string;
+}>;
+export type CommonExpression<E> = OnlyOne<{
+    notEqual: E;
+} & NullExpression>;
+export type Filter<E> = {
+    [key in keyof E]?: E[key] extends PrimaryPartition<number> ? number | OnlyOne<OperationExpression<number> & CommonExpression<number> & InExpression<number>> : E[key] extends PrimaryPartition<string> ? string | OnlyOne<StringExpression & StringFilterExpression & CommonExpression<string> & InExpression<string>> : E[key] extends string | number | boolean | Date | null ? E[key] | (E[key] extends number ? OnlyOne<OperationExpression<number> & CommonExpression<number> & InExpression<number>> : E[key] extends boolean ? CommonExpression<boolean> : E[key] extends null ? NullExpression : OnlyOne<StringExpression & StringFilterExpression & CommonExpression<string> & InExpression<string>>) : DeepPartial<Filter<E[key]>>;
+};
+export type OrFilter<E> = {
+    OR: Array<Filter<E> | AndFilter<E>>;
+};
+export type AndFilter<E> = {
+    AND: Filter<E> | OrFilter<E>;
+};
+export type SortDirectionType = 'asc' | 'desc';
+export type KeyCondition<E> = {
+    partition: Partial<OnlyNumberString<E>>;
+    sort?: {
+        [key in keyof E as E[key] extends number | string ? key : never]?: E[key] extends PrimaryPartition<number> ? number | OperationExpression<E[key]> : E[key] extends PrimaryPartition<string> ? string | OnlyOne<OperationExpression<E[key]> & StringExpression> : E[key] | (E[key] extends number ? OperationExpression<E[key]> : OnlyOne<OperationExpression<E[key]> | StringExpression>);
+    };
+};
+export type Item<E extends Function> = {
+    [key in keyof E['prototype']]: E['prototype'][key];
+};
+export type Cursor<E extends Function> = Partial<E>;
+export type Projection<E extends Function> = KeyOfClass<E>[] | 'ALL';
+export interface FindProps<E extends Function> {
+    /**
+     * Specifies which attributes are included in the query result.
+     * By limiting the projected attributes, the response size can be reduced
+     * and query performance improved.
+     *
+     * @example
+     * projection: ['foo', 'bar']
+     */
+    projection?: Projection<E>;
+    /**
+     * Specifies the filter expression applied to the query or scan operation.
+     * This filter is evaluated after the items are read and is used to narrow
+     * down the result set based on non-key attributes.
+     *
+     * @example
+     * filter: {
+     *   age: {
+     *     lessThan: 25,
+     *   },
+     * }
+     */
+    filter?: Filter<E['prototype']> | OrFilter<E['prototype']>;
+    /**
+     * Specifies the sort order to apply to the query results.
+     * This determines whether items are returned in ascending or descending order.
+     *
+     * @example
+     *
+     * sortDirection: 'asc'
+     */
+    sortDirection?: SortDirectionType;
+    /**
+     * Specifies the cursor representing the last item evaluated in a previous query.
+     * It is used to resume the query from the same position, allowing subsequent
+     * requests to paginate through the query results consistently.
+     *
+     * @example
+     *
+     * {
+     *   cursor: {
+     *     foo: 'some',
+     *     bar: 'item'
+     *   }
+     * }
+     */
+    cursor?: Cursor<E['prototype']>;
+    /**
+     * Specifies the maximum number of items to be retrieved by the query.
+     * This value limits the size of the result set returned by DynamoDB.
+     */
+    limit?: number;
+    /**
+     * Specifies the name of the index to use when executing the query.
+     * If not provided, the index that best matches the attributes defined
+     * in the key condition will be selected automatically.
+     */
+    indexName?: string;
+}
+export interface QueryProps<E extends Function> extends FindProps<E> {
+    /**
+     * Specifies the key condition used to execute the query.
+     * This defines the partition key and, optionally, the sort key
+     * that DynamoDB uses to locate the matching items.
+     *
+     * @example
+     * {
+     *   keyCondition: {
+     *     partition: {
+     *       foo: 'value'
+     *     },
+     *     sort: {
+     *       bar: {
+     *         lessThan: 10
+     *       }
+     *     }
+     *   }
+     * }
+     */
+    keyCondition: KeyCondition<E['prototype']>;
+}
+export interface QueryOneProps<E extends Function> extends Omit<QueryProps<E>, 'limit'> {
+}
+export interface QueryResponse<E extends Function> {
+    data: E['prototype'][];
+    cursor?: Cursor<E['prototype']>;
+}
+export type ObjectToBoolean<T> = {
+    [K in keyof T]?: T[K] extends number | string | boolean | Array<any> | Date ? true : ObjectToBoolean<T[K]> | true;
+};
+interface ExistValue<T> {
+    ifNotExistValue: T;
+}
+interface NumericValues<T> extends ExistValue<T> {
+    incrementValue?: number;
+    decrementValue?: number;
+}
+export type NumericOrExist<T> = T extends number ? number | OnlyOne<NumericValues<T>> : T extends string | boolean | Array<any> | Date ? T | ExistValue<T> : (T & {
+    ifNotExistValue?: never;
+}) | (ExistValue<T> & {
+    [K in keyof T]?: never;
+});
+export type ReplaceValue<T> = {
+    [K in keyof T]?: NumericOrExist<T[K]>;
+};
+export type DeepReplaceValue<T> = {
+    [K in keyof T]?: T[K] extends number | string | boolean | Array<any> | Date ? NumericOrExist<T[K]> : ExistValue<T[K]> | DeepReplaceValue<T[K]>;
+};
+export interface UpdateProps<E extends Function> extends UpsertProps<E> {
+    /**
+     * Specifies the key condition used to execute the update query.
+     * This defines the partition key and, optionally, the sort key
+     * that DynamoDB uses to locate the matching items.
+     *
+     * @example
+     * {
+     *   keyCondition: {
+     *     partition: {
+     *       foo: 'value'
+     *     },
+     *     sort: {
+     *       bar: {
+     *         lessThan: 10
+     *       }
+     *     }
+     *   }
+     * }
+     */
+    keyCondition: TablePartition<Item<E>>;
+    /**
+     * Specifies the attribute values to be replaced on the item.
+     * Unlike full updates, this allows replacing specific parts
+     * of the item without overwriting the entire object.
+     *
+     * @example
+     * {
+     *   setValues: {
+     *     foo: {
+     *       bar: 2 // only replace bar value in foo element
+     *     }
+     *   }
+     * }
+     */
+    setValues?: DeepReplaceValue<Item<E>>;
+    /**
+     * Specifies the values to be updated on the item.
+     * When a value is an object, the entire object is replaced
+     * rather than being merged.
+     *
+     * @example
+     * {
+     *   replaceValues: {
+     *     foo:  {
+     *       bar: 1,
+     *       baz: [1, 2, 3]
+     *     }
+     *   }
+     * }
+     */
+    replaceValues?: ReplaceValue<Item<E>>;
+    /**
+     * Specifies which attributes should be removed from the item
+     * during the update operation.
+     *
+     * @example
+     * {
+     *   removeValues: {
+     *     foo: true
+     *   }
+     * }
+     */
+    removeValues?: ObjectToBoolean<Item<E>>;
+}
+export interface UpsertProps<E extends Function> {
+    /**
+     * Specifies the condition expression used during an item update operation.
+     * The update is only executed if the provided condition evaluates to true.
+     *
+     * condition: {
+     *   foo: 'bar'
+     * }
+     */
+    condition?: Filter<E['prototype']>;
+}
+export interface ModelInformation<E extends ClassResource> {
+    modelProps: ModelMetadata<E>;
+    partitionKey: string;
+    fields: FieldsMetadata;
+    sortKey?: string;
+}
+export {};

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

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

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

@@ -0,0 +1,15 @@
+import { type ScanCommandInput } 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 { ScanBuilderProps } from './scan.types';
+export declare class ScanBuilder<E extends ClassResource> extends QueryBuilderBase<E> {
+    protected queryOptions: ScanBuilderProps<E>;
+    protected command: ScanCommandInput;
+    constructor(queryOptions: ScanBuilderProps<E>);
+    getCommand(): ScanCommandInput;
+    then<T>(resolve: (value: QueryResponse<E>) => T, reject: (reason: any) => T): Promise<T>;
+    private exec;
+    private scan;
+    private runQuery;
+}

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScanBuilder = 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 ScanBuilder extends base_1.QueryBuilderBase {
+    queryOptions;
+    command;
+    constructor(queryOptions) {
+        super(queryOptions);
+        this.queryOptions = queryOptions;
+        this.scan();
+    }
+    getCommand() {
+        return this.command;
+    }
+    then(resolve, reject) {
+        return this.exec().then(resolve, reject);
+    }
+    exec() {
+        return this.runQuery(this.command);
+    }
+    scan() {
+        const { limit, cursor, filter, projection = 'ALL' } = this.queryOptions.inputProps;
+        let filterExpression;
+        if (filter) {
+            filterExpression = this.getFilterExpression(filter || {});
+        }
+        this.command = {
+            TableName: this.queryOptions.modelProps.name,
+            FilterExpression: filterExpression,
+            ExclusiveStartKey: cursor ? (0, util_dynamodb_1.marshall)(cursor) : undefined,
+            Limit: limit,
+            ProjectionExpression: projection === 'ALL' ? undefined : projection.join(', '),
+            ...this.getAttributesAndNames(),
+        };
+    }
+    async runQuery(input, data = []) {
+        const command = new client_dynamodb_1.ScanCommand(input);
+        const { Items = [], LastEvaluatedKey } = await this.queryOptions.client.send(command);
+        const resultData = Items.map((item) => (0, util_dynamodb_1.unmarshall)(item));
+        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.ScanBuilder = ScanBuilder;

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

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

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

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

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

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

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

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateBuilder = 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");
+const update_utils_1 = require("./update.utils");
+class UpdateBuilder 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.UpdateItemCommand(this.command);
+        await this.queryOptions.client.send(command);
+        return true;
+    }
+    prepare() {
+        const { removeValues = {}, replaceValues = {}, setValues = {}, condition, } = this.queryOptions.inputProps;
+        if (Object.keys(removeValues).length > 0 &&
+            Object.keys(replaceValues).length > 0 &&
+            Object.keys(setValues).length > 0) {
+            throw new Error('You must assign a value to update');
+        }
+        let setExpression = this.setValues(setValues, true);
+        if (Object.keys(replaceValues).length > 0) {
+            setExpression += ` ${this.setValues(replaceValues, false)}`;
+        }
+        const removeExpression = this.removeValues(removeValues);
+        const keyCondition = this.queryOptions.inputProps.keyCondition;
+        this.command = {
+            TableName: this.queryOptions.modelProps.name,
+            Key: (0, util_dynamodb_1.marshall)(keyCondition),
+            UpdateExpression: `${setExpression ? `SET ${setExpression}` : ''} ${removeExpression ? `REMOVE ${removeExpression}` : ''}`.trim(),
+            ...this.getAttributesAndNames(),
+            ConditionExpression: condition ? this.getFilterExpression(condition) : undefined,
+        };
+    }
+    setValues(values, isDeepReplace, names = [], counter = 0) {
+        counter += 1;
+        const filterExpression = [];
+        const index = 0;
+        for (const key in values) {
+            const currentKeyNames = [...names, key];
+            const keyName = currentKeyNames.join('.#');
+            const keyValue = `${currentKeyNames.join('_')}_${counter}_${index}`;
+            this.attributeNames[`#${key}`] = key;
+            const name = `#${keyName}`;
+            if (typeof values[key] === 'object' && !Array.isArray(values[key])) {
+                const keys = Object.keys(values[key] || {});
+                const updateResolverKey = keys.find((key) => update_utils_1.updateResolverKeys.has(key));
+                if (updateResolverKey) {
+                    const resolverFn = update_utils_1.updateResolver[updateResolverKey];
+                    const { attributeValues, expression } = resolverFn(name, keyValue, values[key][updateResolverKey]);
+                    this.attributeValues = {
+                        ...this.attributeValues,
+                        ...attributeValues,
+                    };
+                    filterExpression.push(expression);
+                    continue;
+                }
+                if (isDeepReplace) {
+                    filterExpression.push(this.setValues(values[key], true, currentKeyNames, counter));
+                    continue;
+                }
+                filterExpression.push(`#${keyName} = :${keyValue}`);
+                this.attributeValues[`:${keyValue}`] = values[key];
+                continue;
+            }
+            filterExpression.push(`#${keyName} = :${keyValue}`);
+            this.attributeValues[`:${keyValue}`] = values[key];
+        }
+        return filterExpression.join(',').trim();
+    }
+    removeValues(values) {
+        const removedKeys = [];
+        for (const key in values) {
+            const keyValue = `#${key}`;
+            if (typeof values[key] === 'boolean') {
+                this.attributeNames[`#${key}`] = key;
+                removedKeys.push(keyValue);
+                continue;
+            }
+            if (values[key] !== undefined) {
+                const removed = this.removeValues(values[key]);
+                removedKeys.push(removed);
+            }
+        }
+        return removedKeys.join(',');
+    }
+}
+exports.UpdateBuilder = UpdateBuilder;

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

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

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

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

package/lib/service/query-builder/update/update.utils.d.ts

@@ -0,0 +1,11 @@
+export declare const updateResolver: {
+    incrementValue: (key: string, valueName: string, value: any) => import("../base/base.utils").ExpressionResolverResult;
+    decrementValue: (key: string, valueName: string, value: any) => import("../base/base.utils").ExpressionResolverResult;
+    ifNotExistValue: (key: string, valueName: string, value: any) => {
+        expression: string;
+        attributeValues: {
+            [x: string]: any;
+        };
+    };
+};
+export declare const updateResolverKeys: Set<string>;

package/lib/service/query-builder/update/update.utils.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateResolverKeys = exports.updateResolver = void 0;
+const base_utils_1 = require("../base/base.utils");
+exports.updateResolver = {
+    incrementValue: (key, valueName, value) => {
+        return (0, base_utils_1.expressionResolver)(key, valueName, `= ${key} + `, value);
+    },
+    decrementValue: (key, valueName, value) => {
+        return (0, base_utils_1.expressionResolver)(key, valueName, `= ${key} - `, value);
+    },
+    ifNotExistValue: (key, valueName, value) => {
+        const valueResolver = `:${valueName}`;
+        return {
+            expression: `${key} = if_not_exists(${key}, ${valueResolver})`,
+            attributeValues: {
+                [valueResolver]: value,
+            },
+        };
+    },
+};
+exports.updateResolverKeys = new Set([...Object.keys(exports.updateResolver)]);

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

@@ -0,0 +1,14 @@
+import { type PutItemCommandInput } from '@aws-sdk/client-dynamodb';
+import type { ClassResource } from '@lafken/common';
+import { QueryBuilderBase } from '../base/base';
+import type { Item } from '../query-builder.types';
+import type { UpsertBuilderProps } from './upsert.types';
+export declare class UpsertBuilder<E extends ClassResource> extends QueryBuilderBase<E> {
+    private queryOptions;
+    protected command: PutItemCommandInput;
+    constructor(queryOptions: UpsertBuilderProps<E>);
+    getCommand(): PutItemCommandInput;
+    then<T>(resolve: (value: Item<E>) => T, reject: (reason: any) => T): Promise<T>;
+    private exec;
+    protected prepare(): void;
+}

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpsertBuilder = 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 UpsertBuilder 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.PutItemCommand(this.command);
+        await this.queryOptions.client.send(command);
+        return this.queryOptions.item;
+    }
+    prepare() {
+        const { condition } = this.queryOptions.inputProps;
+        let conditionExpression;
+        if (condition) {
+            conditionExpression = this.getFilterExpression(condition);
+        }
+        this.command = {
+            TableName: this.queryOptions.modelProps.name,
+            Item: (0, util_dynamodb_1.marshall)(this.queryOptions.item),
+            ConditionExpression: conditionExpression,
+            ...this.getAttributesAndNames(),
+        };
+    }
+}
+exports.UpsertBuilder = UpsertBuilder;

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

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

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

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

package/lib/service/repository/index.d.ts

@@ -0,0 +1,3 @@
+export * from './repository';
+export * from './repository.types';
+export * from './repository.utils';

package/lib/service/repository/index.js

@@ -0,0 +1,19 @@
+"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("./repository"), exports);
+__exportStar(require("./repository.types"), exports);
+__exportStar(require("./repository.utils"), exports);

package/lib/service/repository/repository.d.ts

@@ -0,0 +1,3 @@
+import type { ClassResource } from '@lafken/common';
+import type { RepositoryReturn } from './repository.types';
+export declare const createRepository: <E extends ClassResource>(model: E) => RepositoryReturn<E>;