@itzworking/single-table 0.0.162 → 0.0.197

package/dist-es/errors/decorators-error.js

@@ -0,0 +1,10 @@
+import { SingleTableError } from "./single-table-error";
+export class DecoratorsError extends SingleTableError {
+    constructor(message) {
+        super({
+            message,
+        });
+        this.name = "DecoratorsError";
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}

package/dist-es/errors/generate-update-expression-error.js

@@ -0,0 +1,10 @@
+import { SingleTableError } from "./single-table-error";
+export class GenerateUpdateExpressionError extends SingleTableError {
+    constructor(message) {
+        super({
+            message,
+        });
+        this.name = "GenerateUpdateExpressionError";
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}

package/dist-es/errors/index-decorator-error.js

@@ -0,0 +1,10 @@
+import { SingleTableError } from "./single-table-error";
+export class IndexDecoratorError extends SingleTableError {
+    constructor(message) {
+        super({
+            message,
+        });
+        this.name = "IndexDecoratorError";
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}

package/dist-es/errors/index.js

@@ -0,0 +1,5 @@
+export * from "./decorators-error";
+export * from "./generate-update-expression-error";
+export * from "./index-decorator-error";
+export * from "./single-table-error";
+export * from "./single-table-item-format-error";

package/dist-es/errors/key-composition-error.js

@@ -0,0 +1,10 @@
+import { SingleTableError } from "./single-table-error";
+export class KeyCompositionError extends SingleTableError {
+    constructor(message) {
+        super({
+            message,
+        });
+        this.name = "KeyCompositionError";
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}

package/dist-es/errors/single-table-error.js

@@ -0,0 +1,10 @@
+export class SingleTableError extends Error {
+    statusCode;
+    constructor(props) {
+        super(JSON.stringify({ props }));
+        const { statusCode = 500 } = props;
+        this.name = "SingleTableError";
+        this.statusCode = statusCode;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}

package/dist-es/errors/single-table-item-format-error.js

@@ -0,0 +1,10 @@
+import { SingleTableError } from "./single-table-error";
+export class SingleTableItemFormatError extends SingleTableError {
+    constructor(message) {
+        super({
+            message,
+        });
+        this.name = "SingleTableItemFormatError";
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}

package/dist-es/index.js

@@ -0,0 +1,6 @@
+export * from "./types";
+export * from "./decorators";
+export * from "./dynamodb";
+export * from "./errors";
+export * from "./single-table-item";
+export * from "./single-table-repository";

package/dist-es/single-table-item/index.js

@@ -0,0 +1 @@
+export * from "./single-table-item";

package/dist-es/single-table-item/single-table-item.js

@@ -0,0 +1,257 @@
+import { __decorate } from "tslib";
+import { v4 as uuid } from "uuid";
+import { Editable, getEntityName, getPKComposition, getSKComposition, isEditable, } from "../decorators";
+import { capitalizeFirstLetter, handleCompositePrimaryKey, validateEntityAnnotations, } from "./utils";
+import { GenerateUpdateExpressionError, IndexDecoratorError, SingleTableItemFormatError, } from "../errors";
+import { Attribute, AttributeType, DecoratedClass, listAttributes, } from "@itzworking/decorated-class";
+export class SingleTableItem extends DecoratedClass {
+    id;
+    createdAt;
+    updatedAt;
+    createdBy;
+    updatedBy;
+    deletedBy;
+    deletedAt;
+    constructor(props = {}) {
+        super(props);
+        validateEntityAnnotations(this);
+        if (!props?.id) {
+            this.generateId();
+        }
+        if (!props?.createdAt) {
+            this.createdAt = new Date();
+        }
+        if (!props?.updatedAt) {
+            this.updatedAt = new Date();
+        }
+    }
+    generateId() {
+        this.id = uuid();
+        return this.id;
+    }
+    type() {
+        return getEntityName(this);
+    }
+    pk() {
+        const keys = getPKComposition(this);
+        if (!keys?.length) {
+            throw new IndexDecoratorError(`@Entity("${this.type()}") @Index: PK is not defined`);
+        }
+        return handleCompositePrimaryKey(this, keys);
+    }
+    sk() {
+        const keys = getSKComposition(this);
+        if (!keys?.length) {
+            throw new IndexDecoratorError(`@Entity("${this.type()}") @Index: SK is not defined`);
+        }
+        return handleCompositePrimaryKey(this, keys);
+    }
+    key() {
+        return {
+            PK: this.pk(),
+            SK: this.sk(),
+        };
+    }
+    gsi1pk() {
+        return handleCompositePrimaryKey(this, getPKComposition(this, "GSI1"));
+    }
+    gsi1sk() {
+        return handleCompositePrimaryKey(this, getSKComposition(this, "GSI1"));
+    }
+    gsi2pk() {
+        return handleCompositePrimaryKey(this, getPKComposition(this, "GSI2"));
+    }
+    gsi2sk() {
+        return handleCompositePrimaryKey(this, getSKComposition(this, "GSI2"));
+    }
+    gsi3pk() {
+        return handleCompositePrimaryKey(this, getPKComposition(this, "GSI3"));
+    }
+    gsi3sk() {
+        return handleCompositePrimaryKey(this, getSKComposition(this, "GSI3"));
+    }
+    gsi4pk() {
+        return handleCompositePrimaryKey(this, getPKComposition(this, "GSI4"));
+    }
+    gsi4sk() {
+        return handleCompositePrimaryKey(this, getSKComposition(this, "GSI4"));
+    }
+    gsi5pk() {
+        return handleCompositePrimaryKey(this, getPKComposition(this, "GSI5"));
+    }
+    gsi5sk() {
+        return handleCompositePrimaryKey(this, getSKComposition(this, "GSI5"));
+    }
+    generateUpdateExpression(attributes = []) {
+        const attributesToUpdate = [];
+        const entityAttributes = listAttributes(this);
+        if (attributes?.length) {
+            for (const attribute of attributes) {
+                if (entityAttributes.find((ef) => ef.attributeName === attribute)) {
+                    attributesToUpdate.push(attribute);
+                }
+                else {
+                    throw new GenerateUpdateExpressionError(`@Entity("${this.type()}"): ${attribute} is not an @Attribute`);
+                }
+            }
+        }
+        else {
+            for (const attribute of entityAttributes) {
+                if (!isEditable(this, attribute.attributeName)) {
+                    continue;
+                }
+                attributesToUpdate.push(attribute.attributeName);
+            }
+        }
+        if (attributesToUpdate.length === 0) {
+            throw new GenerateUpdateExpressionError(`@Entity("${this.type()}"): attributesToUpdate is empty; attributes = ${attributes}`);
+        }
+        else {
+            const indexComposition = {
+                PK: getPKComposition(this),
+                SK: getSKComposition(this),
+            };
+            const indexPkSkAttributes = [
+                ...(indexComposition.PK || []),
+                ...(indexComposition.SK || []),
+            ];
+            const notAllowedAttributes = indexPkSkAttributes.filter((attribute) => attributesToUpdate.includes(attribute));
+            if (notAllowedAttributes.length > 0) {
+                throw new GenerateUpdateExpressionError(`@Entity("${this.type()}"): cannot update @Index notAllowedAttributes = ${notAllowedAttributes}`);
+            }
+        }
+        const attributeValues = {};
+        const attributeNames = {};
+        const namesAndValues = [];
+        const attributesToRemove = [];
+        const gsis = {
+            GSI1: {
+                PK: getPKComposition(this, "GSI1"),
+                SK: getSKComposition(this, "GSI1"),
+            },
+            GSI2: {
+                PK: getPKComposition(this, "GSI2"),
+                SK: getSKComposition(this, "GSI2"),
+            },
+            GSI3: {
+                PK: getPKComposition(this, "GSI3"),
+                SK: getSKComposition(this, "GSI3"),
+            },
+            GSI4: {
+                PK: getPKComposition(this, "GSI4"),
+                SK: getSKComposition(this, "GSI4"),
+            },
+            GSI5: {
+                PK: getPKComposition(this, "GSI5"),
+                SK: getSKComposition(this, "GSI5"),
+            },
+        };
+        for (const [gsiKey, gsiComposition] of Object.entries(gsis)) {
+            for (const [gsiAttributeKey, gsiAttributeComposition] of Object.entries(gsiComposition)) {
+                if (gsiAttributeComposition?.some((key) => attributesToUpdate.includes(key))) {
+                    attributeNames[`#key${gsiKey}${gsiAttributeKey}`] = `${gsiKey}${gsiAttributeKey}`;
+                    attributeValues[`:value${gsiKey}${gsiAttributeKey}`] = this[`${gsiKey}${gsiAttributeKey}`.toLowerCase()]();
+                    namesAndValues.push(`#key${gsiKey}${gsiAttributeKey} = :value${gsiKey}${gsiAttributeKey}`);
+                }
+            }
+        }
+        for (const key of attributesToUpdate) {
+            const keyToUse = capitalizeFirstLetter(key);
+            const value = this[key];
+            attributeNames[`#key${keyToUse}`] = key;
+            if (value === undefined) {
+                attributesToRemove.push(`#key${keyToUse}`);
+            }
+            else {
+                attributeValues[`:value${keyToUse}`] =
+                    value instanceof Date ? value.toISOString() : value;
+                namesAndValues.push(`#key${keyToUse} = :value${keyToUse}`);
+            }
+        }
+        return {
+            UpdateExpression: ((namesAndValues.length ? `SET ${namesAndValues.join(", ")} ` : "") +
+                (attributesToRemove.length
+                    ? `REMOVE ${attributesToRemove.join(", ")}`
+                    : "")).trim(),
+            ExpressionAttributeNames: attributeNames,
+            ExpressionAttributeValues: attributeValues,
+        };
+    }
+    toSingleTableItem() {
+        const result = {
+            type: this.type(),
+            ...this.key(),
+        };
+        if (this.gsi1pk() && this.gsi1sk()) {
+            result.GSI1PK = this.gsi1pk();
+            result.GSI1SK = this.gsi1sk();
+        }
+        if (this.gsi2pk() && this.gsi2sk()) {
+            result.GSI2PK = this.gsi2pk();
+            result.GSI2SK = this.gsi2sk();
+        }
+        if (this.gsi3pk() && this.gsi3sk()) {
+            result.GSI3PK = this.gsi3pk();
+            result.GSI3SK = this.gsi3sk();
+        }
+        if (this.gsi4pk() && this.gsi4sk()) {
+            result.GSI4PK = this.gsi4pk();
+            result.GSI4SK = this.gsi4sk();
+        }
+        if (this.gsi5pk() && this.gsi5sk()) {
+            result.GSI5PK = this.gsi5pk();
+            result.GSI5SK = this.gsi5sk();
+        }
+        const attributes = listAttributes(this);
+        const reservedKeys = [
+            "type",
+            "PK",
+            "SK",
+            "GSI1PK",
+            "GSI1SK",
+            "GSI2PK",
+            "GSI2SK",
+            "GSI3PK",
+            "GSI3SK",
+            "GSI4PK",
+            "GSI4SK",
+            "GSI5PK",
+            "GSI5SK",
+        ];
+        const reservedKeysInUse = reservedKeys.filter((reservedKey) => attributes.find((f) => f.attributeName === reservedKey));
+        if (reservedKeysInUse.length > 0) {
+            throw new SingleTableItemFormatError(`@Entity("${this.type()}"): cannot use reserved keys in attributes = ${reservedKeysInUse}`);
+        }
+        for (const attribute of attributes) {
+            const value = this[attribute.attributeName];
+            if (value !== undefined) {
+                result[attribute.attributeName] =
+                    value instanceof Date ? value.toISOString() : value;
+            }
+        }
+        return result;
+    }
+}
+__decorate([
+    Attribute(AttributeType.String)
+], SingleTableItem.prototype, "id", void 0);
+__decorate([
+    Attribute(AttributeType.Date)
+], SingleTableItem.prototype, "createdAt", void 0);
+__decorate([
+    Editable,
+    Attribute(AttributeType.Date)
+], SingleTableItem.prototype, "updatedAt", void 0);
+__decorate([
+    Attribute(AttributeType.String)
+], SingleTableItem.prototype, "createdBy", void 0);
+__decorate([
+    Editable,
+    Attribute(AttributeType.String)
+], SingleTableItem.prototype, "updatedBy", void 0);
+__decorate([
+    Attribute(AttributeType.String)
+], SingleTableItem.prototype, "deletedBy", void 0);
+__decorate([
+    Attribute(AttributeType.Date)
+], SingleTableItem.prototype, "deletedAt", void 0);

package/dist-es/single-table-item/utils/capitalize-first-letter.js

@@ -0,0 +1,3 @@
+export const capitalizeFirstLetter = (s) => {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+};

package/dist-es/single-table-item/utils/handle-composite-primary-key.js

@@ -0,0 +1,33 @@
+import { AttributeType, listAttributes, PrimitiveType, } from "@itzworking/decorated-class";
+import { KeyCompositionError } from "../../errors/key-composition-error";
+const isPrimitiveType = (type) => {
+    return Object.values(PrimitiveType).includes(type);
+};
+export const handleCompositePrimaryKey = (target, keys) => {
+    if (!keys?.length) {
+        return "";
+    }
+    const entityAttributes = listAttributes(target);
+    const result = [];
+    for (const key of keys) {
+        const entityAttribute = entityAttributes.find((attDef) => attDef.attributeName === key);
+        if (entityAttribute) {
+            if (!isPrimitiveType(entityAttribute?.attributeType)) {
+                throw new KeyCompositionError(`Composite primary key must all be primitive type - @Entity("${target.type()}"): ${key}`);
+            }
+            if (target[key] === undefined) {
+                result.push("null");
+            }
+            else if (entityAttribute.attributeType === AttributeType.Date) {
+                result.push(target[key].toISOString());
+            }
+            else {
+                result.push(target[key]);
+            }
+        }
+        else {
+            result.push(key);
+        }
+    }
+    return result.join("#");
+};

package/dist-es/single-table-item/utils/index.js

@@ -0,0 +1,3 @@
+export * from "./capitalize-first-letter";
+export * from "./handle-composite-primary-key";
+export * from "./validate-entity-annotations";

package/dist-es/single-table-item/utils/validate-entity-annotations.js

@@ -0,0 +1,16 @@
+import { DecoratorsError } from "../../errors";
+export const validateEntityAnnotations = (entity) => {
+    const errors = [];
+    if (!entity.type()) {
+        errors.push("missing @Entity annotation on SingleTableItem class");
+    }
+    try {
+        entity.key();
+    }
+    catch (e) {
+        errors.push("missing @Index annotation on SingleTableItem class");
+    }
+    if (errors.length) {
+        throw new DecoratorsError(errors.join(","));
+    }
+};

package/dist-es/single-table-repository/index.js

@@ -0,0 +1,2 @@
+export * from "./single-table-repository";
+export * from "./types";

package/dist-es/single-table-repository/single-table-repository.js

@@ -0,0 +1,189 @@
+import { deleteDynamodbItem, getDynamodbItem, putDynamodbItem, queryAllDynamodb, queryDynamodb, updateDynamodbItem, } from "../dynamodb";
+import { getContext, NotFoundError } from "@itzworking/powertools";
+export class SingleTableRepository {
+    tableName = process.env.MAIN_TABLE_NAME || process.env.MAIN_TABLE_TABLE_NAME || "";
+    getUserId() {
+        try {
+            return getContext().user?.id || "unknown";
+        }
+        catch (e) {
+            return "unknown";
+        }
+    }
+    async insert(entity, options) {
+        const now = new Date();
+        entity.createdAt = now;
+        entity.updatedAt = now;
+        const userId = this.getUserId();
+        entity.createdBy = userId;
+        entity.updatedBy = userId;
+        let retryLimit = options?.override ? 1 : 3;
+        while (retryLimit > 0) {
+            try {
+                await putDynamodbItem({
+                    TableName: this.tableName || "",
+                    Item: entity.toSingleTableItem(),
+                    ConditionExpression: options?.override
+                        ? undefined
+                        : "attribute_not_exists(PK) AND attribute_not_exists(SK)",
+                    ...options?.input,
+                });
+                retryLimit = 0;
+            }
+            catch (error) {
+                if (error.name === "ConditionalCheckFailedException" &&
+                    retryLimit > 1) {
+                    entity.generateId();
+                    retryLimit--;
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        return entity;
+    }
+    async get(entity, options) {
+        const { Item: item } = await getDynamodbItem({
+            TableName: this.tableName || "",
+            Key: entity.key(),
+            ...options?.input,
+        });
+        if (!item) {
+            throw new NotFoundError(`Item not found: ${JSON.stringify(entity.key())}`);
+        }
+        const EntityClass = Object.getPrototypeOf(entity).constructor;
+        return new EntityClass(item);
+    }
+    async update(entity, options) {
+        if (options?.attributes?.length) {
+            if (!options.attributes.includes("updatedAt")) {
+                options.attributes.push("updatedAt");
+            }
+            if (!options.attributes.includes("updatedBy")) {
+                options.attributes.push("updatedBy");
+            }
+        }
+        entity.updatedAt = new Date();
+        entity.updatedBy = this.getUserId();
+        const dynamodbResponse = await updateDynamodbItem({
+            TableName: this.tableName || "",
+            Key: entity.key(),
+            ReturnValues: "ALL_NEW",
+            ...entity.generateUpdateExpression((options?.attributes || [])),
+            ...options?.input,
+        });
+        const EntityClass = Object.getPrototypeOf(entity).constructor;
+        return new EntityClass(dynamodbResponse?.Attributes ?? entity);
+    }
+    async delete(entity, options) {
+        entity.deletedAt = new Date();
+        entity.deletedBy = this.getUserId();
+        await updateDynamodbItem({
+            TableName: options?.input?.TableName || this.tableName || "",
+            Key: options?.input?.Key || entity.key(),
+            ReturnValues: "NONE",
+            ...entity.generateUpdateExpression(["deletedAt", "deletedBy"]),
+        });
+        await deleteDynamodbItem({
+            TableName: this.tableName || "",
+            Key: entity.key(),
+            ...options?.input,
+        });
+    }
+    async query(entity, options) {
+        return this.queryMultipleEntityTypes(entity, {
+            ...options,
+            entityClasses: [entity.constructor],
+        });
+    }
+    async queryMultipleEntityTypes(entity, options) {
+        if (options.sortKey && Object.keys(options.sortKey).length > 1) {
+            throw new Error("Only one sort key condition is allowed");
+        }
+        const typeAndConstructor = {};
+        for (const entityClass of options.entityClasses) {
+            typeAndConstructor[new entityClass().type()] = entityClass;
+        }
+        const index = options.index || "";
+        let KeyConditionExpression = "#pk = :pk";
+        const ExpressionAttributeNames = {
+            "#pk": `${index}PK`,
+        };
+        const ExpressionAttributeValues = {
+            ":pk": `${entity[`${index.toLowerCase()}pk`]()}`,
+        };
+        if (options.sortKey && Object.keys(options.sortKey).length > 0) {
+            ExpressionAttributeNames["#sk"] = `${index}SK`;
+            if (options.sortKey.equalTo !== undefined) {
+                KeyConditionExpression += " and #sk = :sk";
+                ExpressionAttributeValues[":sk"] = options.sortKey.equalTo;
+            }
+            else if (options.sortKey.lessThanOrEqualTo !== undefined) {
+                KeyConditionExpression += " and #sk <= :sk";
+                ExpressionAttributeValues[":sk"] = options.sortKey.lessThanOrEqualTo;
+            }
+            else if (options.sortKey.lessThan !== undefined) {
+                KeyConditionExpression += " and #sk < :sk";
+                ExpressionAttributeValues[":sk"] = options.sortKey.lessThan;
+            }
+            else if (options.sortKey.greaterThanOrEqualTo !== undefined) {
+                KeyConditionExpression += " and #sk >= :sk";
+                ExpressionAttributeValues[":sk"] = options.sortKey.greaterThanOrEqualTo;
+            }
+            else if (options.sortKey.greaterThan !== undefined) {
+                KeyConditionExpression += " and #sk > :sk";
+                ExpressionAttributeValues[":sk"] = options.sortKey.greaterThan;
+            }
+            else if (options.sortKey.between !== undefined &&
+                options.sortKey.between.length === 2) {
+                KeyConditionExpression += " and #sk between :sk1 and :sk2";
+                ExpressionAttributeValues[":sk"] = options.sortKey.between[0];
+                ExpressionAttributeValues[":sk2"] = options.sortKey.between[1];
+            }
+            else if (options.sortKey.beginsWith !== undefined) {
+                KeyConditionExpression += " and begins_with(#sk, :sk)";
+                ExpressionAttributeValues[":sk"] = options.sortKey.beginsWith;
+            }
+            else {
+                throw new Error("Invalid sort key condition");
+            }
+        }
+        const response = {
+            items: [],
+        };
+        let dynamodbItems;
+        if (options?.queryAll) {
+            dynamodbItems = await queryAllDynamodb({
+                TableName: this.tableName || "",
+                IndexName: options.index,
+                KeyConditionExpression,
+                ExpressionAttributeNames,
+                ExpressionAttributeValues,
+                ...options?.input,
+            });
+        }
+        else {
+            const { Items, LastEvaluatedKey } = await queryDynamodb({
+                TableName: this.tableName || "",
+                IndexName: options.index,
+                KeyConditionExpression,
+                ExpressionAttributeNames,
+                ExpressionAttributeValues,
+                ...options?.input,
+            });
+            if (LastEvaluatedKey) {
+                response.lastEvaluatedKey = LastEvaluatedKey;
+            }
+            dynamodbItems = Items || [];
+        }
+        for (const dynamodbItem of dynamodbItems) {
+            const entityClass = typeAndConstructor[dynamodbItem.type];
+            if (!entityClass) {
+                throw new Error(`Entity class not found for type ${dynamodbItem.type}`);
+            }
+            response.items.push(new entityClass(dynamodbItem));
+        }
+        return response;
+    }
+}

package/dist-es/single-table-repository/types.js

@@ -0,0 +1 @@
+export {};

package/dist-es/types.js

@@ -0,0 +1 @@
+export {};

package/{dist → dist-types}/decorators/editable/editable.d.ts

@@ -1,4 +1,3 @@
 export declare const Editable: (target: any, context: string | (ClassFieldDecoratorContext & {
     name: string;
 })) => void;
-//# sourceMappingURL=editable.d.ts.map

package/{dist → dist-types}/decorators/editable/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./editable";
 export * from "./is-editable";
-//# sourceMappingURL=index.d.ts.map

package/{dist → dist-types}/decorators/editable/is-editable.d.ts

@@ -1,2 +1 @@
 export declare const isEditable: (target: any, propertyKey: string) => boolean;
-//# sourceMappingURL=is-editable.d.ts.map

package/{dist → dist-types}/decorators/editable/symbol.d.ts

@@ -1,2 +1 @@
 export declare const symbol: unique symbol;
-//# sourceMappingURL=symbol.d.ts.map

package/{dist → dist-types}/decorators/entity/entity.d.ts

@@ -1,4 +1,3 @@
 export declare const Entity: (name: string) => <C extends {
     new (...args: any[]): any;
 }>(constructor: C, ctx?: ClassDecoratorContext) => void;
-//# sourceMappingURL=entity.d.ts.map

package/{dist → dist-types}/decorators/entity/get-entity-name.d.ts

@@ -1,2 +1 @@
 export declare const getEntityName: (target: any) => any;
-//# sourceMappingURL=get-entity-name.d.ts.map

package/{dist → dist-types}/decorators/entity/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./entity";
 export * from "./get-entity-name";
-//# sourceMappingURL=index.d.ts.map

package/{dist → dist-types}/decorators/entity/symbol.d.ts

@@ -1,2 +1 @@
 export declare const symbol: unique symbol;
-//# sourceMappingURL=symbol.d.ts.map

package/{dist → dist-types}/decorators/gsis/get-pk-composition.d.ts

@@ -1,3 +1,2 @@
 import { symbols } from "./symbols";
 export declare const getPKComposition: (target: any, name?: keyof typeof symbols) => string[];
-//# sourceMappingURL=get-pk-composition.d.ts.map

package/{dist → dist-types}/decorators/gsis/get-sk-composition.d.ts

@@ -1,3 +1,2 @@
 import { symbols } from "./symbols";
 export declare const getSKComposition: (target: any, name?: keyof typeof symbols) => string[];
-//# sourceMappingURL=get-sk-composition.d.ts.map

package/{dist → dist-types}/decorators/gsis/gsis.d.ts

@@ -17,4 +17,3 @@ export declare const GSI4: <T>(keyComposition: CompositePrimaryKeyComposition<T>
 export declare const GSI5: <T>(keyComposition: CompositePrimaryKeyComposition<T>) => (constructor: {
     new (...args: any[]): T;
 }, context?: ClassDecoratorContext) => void;
-//# sourceMappingURL=gsis.d.ts.map

package/{dist → dist-types}/decorators/gsis/index.d.ts

@@ -1,4 +1,3 @@
 export * from "./gsis";
 export * from "./get-pk-composition";
 export * from "./get-sk-composition";
-//# sourceMappingURL=index.d.ts.map