dyno-table 0.2.0-0 → 1.0.0-alpha.1

package/dist/utils/partition-key-template.cjs

@@ -1,19 +0,0 @@
-'use strict';
-
-// src/utils/partition-key-template.ts
-function partitionKey(strings, ...keys) {
-  return (params) => {
-    let result = strings[0] ?? "";
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i];
-      if (key) {
-        result += params[key] + (strings[i + 1] ?? "");
-      }
-    }
-    return result;
-  };
-}
-
-exports.partitionKey = partitionKey;
-//# sourceMappingURL=partition-key-template.cjs.map
-//# sourceMappingURL=partition-key-template.cjs.map

package/dist/utils/partition-key-template.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/utils/partition-key-template.ts"],"names":[],"mappings":";;;AA8BO,SAAS,YAAA,CACd,YACG,IACwC,EAAA;AAC3C,EAAA,OAAO,CAAC,MAAW,KAAA;AACjB,IAAI,IAAA,MAAA,GAAS,OAAQ,CAAA,CAAC,CAAK,IAAA,EAAA;AAE3B,IAAA,KAAA,IAAS,CAAI,GAAA,CAAA,EAAG,CAAI,GAAA,IAAA,CAAK,QAAQ,CAAK,EAAA,EAAA;AACpC,MAAM,MAAA,GAAA,GAAM,KAAK,CAAC,CAAA;AAClB,MAAA,IAAI,GAAK,EAAA;AACP,QAAA,MAAA,IAAU,OAAO,GAAgB,CAAA,IAAK,OAAQ,CAAA,CAAA,GAAI,CAAC,CAAK,IAAA,EAAA,CAAA;AAAA;AAC1D;AAGF,IAAO,OAAA,MAAA;AAAA,GACT;AACF","file":"partition-key-template.cjs","sourcesContent":["export type StrictGenerateType<T extends readonly string[]> = {\n  [K in T[number]]: string;\n};\n\n/**\n * Creates a template function for generating DynamoDB partition keys with dynamic values.\n * Use this function when you need to:\n * - Create consistent partition key patterns with variable parts\n * - Generate partition keys that follow a specific format\n * - Ensure type safety for partition key parameters\n * - Require all parameters to be provided\n *\n * @example\n * ```ts\n * // Define a partition key template\n * const pk = partitionKey`country#${\"country\"}#enclosure#${\"enclosure\"}`;\n *\n * // Generate a partition key (all parameters required)\n * const key = pk({ country: \"NZ\", enclosure: \"A1\" });\n * // Result: \"country#NZ#enclosure#A1\"\n *\n * // Type checking ensures all parameters are provided\n * const invalidKey = pk({ country: \"NZ\" }); // TypeScript error\n * ```\n *\n * @param strings - The static parts of the template string\n * @param keys - The dynamic parts of the template string that will be replaced with values\n *\n * @returns A function that accepts an object with the dynamic values and returns the formatted partition key\n */\nexport function partitionKey<T extends readonly string[]>(\n  strings: TemplateStringsArray,\n  ...keys: T\n): (params: StrictGenerateType<T>) => string {\n  return (params) => {\n    let result = strings[0] ?? \"\";\n\n    for (let i = 0; i < keys.length; i++) {\n      const key = keys[i];\n      if (key) {\n        result += params[key as T[number]] + (strings[i + 1] ?? \"\");\n      }\n    }\n\n    return result;\n  };\n}\n"]}

package/dist/utils/partition-key-template.d.cts

@@ -1,32 +0,0 @@
-type StrictGenerateType<T extends readonly string[]> = {
-    [K in T[number]]: string;
-};
-/**
- * Creates a template function for generating DynamoDB partition keys with dynamic values.
- * Use this function when you need to:
- * - Create consistent partition key patterns with variable parts
- * - Generate partition keys that follow a specific format
- * - Ensure type safety for partition key parameters
- * - Require all parameters to be provided
- *
- * @example
- * ```ts
- * // Define a partition key template
- * const pk = partitionKey`country#${"country"}#enclosure#${"enclosure"}`;
- *
- * // Generate a partition key (all parameters required)
- * const key = pk({ country: "NZ", enclosure: "A1" });
- * // Result: "country#NZ#enclosure#A1"
- *
- * // Type checking ensures all parameters are provided
- * const invalidKey = pk({ country: "NZ" }); // TypeScript error
- * ```
- *
- * @param strings - The static parts of the template string
- * @param keys - The dynamic parts of the template string that will be replaced with values
- *
- * @returns A function that accepts an object with the dynamic values and returns the formatted partition key
- */
-declare function partitionKey<T extends readonly string[]>(strings: TemplateStringsArray, ...keys: T): (params: StrictGenerateType<T>) => string;
-
-export { type StrictGenerateType, partitionKey };

package/dist/utils/partition-key-template.d.ts

@@ -1,32 +0,0 @@
-type StrictGenerateType<T extends readonly string[]> = {
-    [K in T[number]]: string;
-};
-/**
- * Creates a template function for generating DynamoDB partition keys with dynamic values.
- * Use this function when you need to:
- * - Create consistent partition key patterns with variable parts
- * - Generate partition keys that follow a specific format
- * - Ensure type safety for partition key parameters
- * - Require all parameters to be provided
- *
- * @example
- * ```ts
- * // Define a partition key template
- * const pk = partitionKey`country#${"country"}#enclosure#${"enclosure"}`;
- *
- * // Generate a partition key (all parameters required)
- * const key = pk({ country: "NZ", enclosure: "A1" });
- * // Result: "country#NZ#enclosure#A1"
- *
- * // Type checking ensures all parameters are provided
- * const invalidKey = pk({ country: "NZ" }); // TypeScript error
- * ```
- *
- * @param strings - The static parts of the template string
- * @param keys - The dynamic parts of the template string that will be replaced with values
- *
- * @returns A function that accepts an object with the dynamic values and returns the formatted partition key
- */
-declare function partitionKey<T extends readonly string[]>(strings: TemplateStringsArray, ...keys: T): (params: StrictGenerateType<T>) => string;
-
-export { type StrictGenerateType, partitionKey };

package/dist/utils/partition-key-template.js

@@ -1,17 +0,0 @@
-// src/utils/partition-key-template.ts
-function partitionKey(strings, ...keys) {
-  return (params) => {
-    let result = strings[0] ?? "";
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i];
-      if (key) {
-        result += params[key] + (strings[i + 1] ?? "");
-      }
-    }
-    return result;
-  };
-}
-
-export { partitionKey };
-//# sourceMappingURL=partition-key-template.js.map
-//# sourceMappingURL=partition-key-template.js.map

package/dist/utils/partition-key-template.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/utils/partition-key-template.ts"],"names":[],"mappings":";AA8BO,SAAS,YAAA,CACd,YACG,IACwC,EAAA;AAC3C,EAAA,OAAO,CAAC,MAAW,KAAA;AACjB,IAAI,IAAA,MAAA,GAAS,OAAQ,CAAA,CAAC,CAAK,IAAA,EAAA;AAE3B,IAAA,KAAA,IAAS,CAAI,GAAA,CAAA,EAAG,CAAI,GAAA,IAAA,CAAK,QAAQ,CAAK,EAAA,EAAA;AACpC,MAAM,MAAA,GAAA,GAAM,KAAK,CAAC,CAAA;AAClB,MAAA,IAAI,GAAK,EAAA;AACP,QAAA,MAAA,IAAU,OAAO,GAAgB,CAAA,IAAK,OAAQ,CAAA,CAAA,GAAI,CAAC,CAAK,IAAA,EAAA,CAAA;AAAA;AAC1D;AAGF,IAAO,OAAA,MAAA;AAAA,GACT;AACF","file":"partition-key-template.js","sourcesContent":["export type StrictGenerateType<T extends readonly string[]> = {\n  [K in T[number]]: string;\n};\n\n/**\n * Creates a template function for generating DynamoDB partition keys with dynamic values.\n * Use this function when you need to:\n * - Create consistent partition key patterns with variable parts\n * - Generate partition keys that follow a specific format\n * - Ensure type safety for partition key parameters\n * - Require all parameters to be provided\n *\n * @example\n * ```ts\n * // Define a partition key template\n * const pk = partitionKey`country#${\"country\"}#enclosure#${\"enclosure\"}`;\n *\n * // Generate a partition key (all parameters required)\n * const key = pk({ country: \"NZ\", enclosure: \"A1\" });\n * // Result: \"country#NZ#enclosure#A1\"\n *\n * // Type checking ensures all parameters are provided\n * const invalidKey = pk({ country: \"NZ\" }); // TypeScript error\n * ```\n *\n * @param strings - The static parts of the template string\n * @param keys - The dynamic parts of the template string that will be replaced with values\n *\n * @returns A function that accepts an object with the dynamic values and returns the formatted partition key\n */\nexport function partitionKey<T extends readonly string[]>(\n  strings: TemplateStringsArray,\n  ...keys: T\n): (params: StrictGenerateType<T>) => string {\n  return (params) => {\n    let result = strings[0] ?? \"\";\n\n    for (let i = 0; i < keys.length; i++) {\n      const key = keys[i];\n      if (key) {\n        result += params[key as T[number]] + (strings[i + 1] ?? \"\");\n      }\n    }\n\n    return result;\n  };\n}\n"]}

package/dist/utils/sort-key-template.cjs

@@ -1,19 +0,0 @@
-'use strict';
-
-// src/utils/sort-key-template.ts
-function sortKey(strings, ...keys) {
-  return (params) => {
-    let result = strings[0] ?? "";
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i];
-      if (key && params && key in params) {
-        result += params[key] + (strings[i + 1] ?? "");
-      }
-    }
-    return result;
-  };
-}
-
-exports.sortKey = sortKey;
-//# sourceMappingURL=sort-key-template.cjs.map
-//# sourceMappingURL=sort-key-template.cjs.map

package/dist/utils/sort-key-template.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/utils/sort-key-template.ts"],"names":[],"mappings":";;;AAqCO,SAAS,OAAA,CACd,YACG,IACkC,EAAA;AACrC,EAAA,OAAO,CAAC,MAAW,KAAA;AACjB,IAAI,IAAA,MAAA,GAAS,OAAQ,CAAA,CAAC,CAAK,IAAA,EAAA;AAE3B,IAAA,KAAA,IAAS,CAAI,GAAA,CAAA,EAAG,CAAI,GAAA,IAAA,CAAK,QAAQ,CAAK,EAAA,EAAA;AACpC,MAAM,MAAA,GAAA,GAAM,KAAK,CAAC,CAAA;AAElB,MAAI,IAAA,GAAA,IAAO,MAAU,IAAA,GAAA,IAAO,MAAQ,EAAA;AAClC,QAAA,MAAA,IAAU,OAAO,GAAG,CAAA,IAAK,OAAQ,CAAA,CAAA,GAAI,CAAC,CAAK,IAAA,EAAA,CAAA;AAAA;AAC7C;AAGF,IAAO,OAAA,MAAA;AAAA,GACT;AACF","file":"sort-key-template.cjs","sourcesContent":["export type GenerateType<T extends readonly string[], U extends string = never> = T extends [infer F, ...infer R]\n  ? F extends string\n    ? R extends string[]\n      ? ({ [K in F | U]: string | number } & Partial<Record<Exclude<T[number], F | U>, never>>) | GenerateType<R, F | U>\n      : never\n    : never\n  : never;\n\n/**\n * Creates a template function for generating DynamoDB sort keys with dynamic values.\n * Use this function when you need to:\n * - Create consistent sort key patterns with variable parts\n * - Generate sort keys that follow a specific format\n * - Ensure type safety for sort key parameters\n *\n * @example\n * ```ts\n * // Define a sort key template\n * const sk = sortKey`country#${\"country\"}#enclosure#${\"enclosure\"}#diet#${\"diet\"}`;\n *\n * // Generate a sort key with partial parameters\n * const templatedString = sk({ country: \"NZ\", enclosure: \"A1\" });\n * // Result: \"country#NZ#enclosure#A1#diet#\"\n *\n * // Generate a complete sort key\n * const fullKey = sk({ country: \"NZ\", enclosure: \"A1\", diet: \"carnivore\" });\n * // Result: \"country#NZ#enclosure#A1#diet#carnivore\"\n *\n * // Type checking ensures only valid parameters are used\n * const invalidKey = sk({ country: \"NZ\", invalid: \"value\" }); // TypeScript error\n * ```\n *\n * @param strings - The static parts of the template string\n * @param keys - The dynamic parts of the template string that will be replaced with values\n *\n * @returns A function that accepts an object with the dynamic values and returns the formatted sort key\n */\nexport function sortKey<T extends readonly string[]>(\n  strings: TemplateStringsArray,\n  ...keys: T\n): (params: GenerateType<T>) => string {\n  return (params) => {\n    let result = strings[0] ?? \"\";\n\n    for (let i = 0; i < keys.length; i++) {\n      const key = keys[i];\n\n      if (key && params && key in params) {\n        result += params[key] + (strings[i + 1] ?? \"\");\n      }\n    }\n\n    return result;\n  };\n}\n"]}

package/dist/utils/sort-key-template.d.cts

@@ -1,35 +0,0 @@
-type GenerateType<T extends readonly string[], U extends string = never> = T extends [infer F, ...infer R] ? F extends string ? R extends string[] ? ({
-    [K in F | U]: string | number;
-} & Partial<Record<Exclude<T[number], F | U>, never>>) | GenerateType<R, F | U> : never : never : never;
-/**
- * Creates a template function for generating DynamoDB sort keys with dynamic values.
- * Use this function when you need to:
- * - Create consistent sort key patterns with variable parts
- * - Generate sort keys that follow a specific format
- * - Ensure type safety for sort key parameters
- *
- * @example
- * ```ts
- * // Define a sort key template
- * const sk = sortKey`country#${"country"}#enclosure#${"enclosure"}#diet#${"diet"}`;
- *
- * // Generate a sort key with partial parameters
- * const templatedString = sk({ country: "NZ", enclosure: "A1" });
- * // Result: "country#NZ#enclosure#A1#diet#"
- *
- * // Generate a complete sort key
- * const fullKey = sk({ country: "NZ", enclosure: "A1", diet: "carnivore" });
- * // Result: "country#NZ#enclosure#A1#diet#carnivore"
- *
- * // Type checking ensures only valid parameters are used
- * const invalidKey = sk({ country: "NZ", invalid: "value" }); // TypeScript error
- * ```
- *
- * @param strings - The static parts of the template string
- * @param keys - The dynamic parts of the template string that will be replaced with values
- *
- * @returns A function that accepts an object with the dynamic values and returns the formatted sort key
- */
-declare function sortKey<T extends readonly string[]>(strings: TemplateStringsArray, ...keys: T): (params: GenerateType<T>) => string;
-
-export { type GenerateType, sortKey };

package/dist/utils/sort-key-template.d.ts

@@ -1,35 +0,0 @@
-type GenerateType<T extends readonly string[], U extends string = never> = T extends [infer F, ...infer R] ? F extends string ? R extends string[] ? ({
-    [K in F | U]: string | number;
-} & Partial<Record<Exclude<T[number], F | U>, never>>) | GenerateType<R, F | U> : never : never : never;
-/**
- * Creates a template function for generating DynamoDB sort keys with dynamic values.
- * Use this function when you need to:
- * - Create consistent sort key patterns with variable parts
- * - Generate sort keys that follow a specific format
- * - Ensure type safety for sort key parameters
- *
- * @example
- * ```ts
- * // Define a sort key template
- * const sk = sortKey`country#${"country"}#enclosure#${"enclosure"}#diet#${"diet"}`;
- *
- * // Generate a sort key with partial parameters
- * const templatedString = sk({ country: "NZ", enclosure: "A1" });
- * // Result: "country#NZ#enclosure#A1#diet#"
- *
- * // Generate a complete sort key
- * const fullKey = sk({ country: "NZ", enclosure: "A1", diet: "carnivore" });
- * // Result: "country#NZ#enclosure#A1#diet#carnivore"
- *
- * // Type checking ensures only valid parameters are used
- * const invalidKey = sk({ country: "NZ", invalid: "value" }); // TypeScript error
- * ```
- *
- * @param strings - The static parts of the template string
- * @param keys - The dynamic parts of the template string that will be replaced with values
- *
- * @returns A function that accepts an object with the dynamic values and returns the formatted sort key
- */
-declare function sortKey<T extends readonly string[]>(strings: TemplateStringsArray, ...keys: T): (params: GenerateType<T>) => string;
-
-export { type GenerateType, sortKey };

package/dist/utils/sort-key-template.js

@@ -1,17 +0,0 @@
-// src/utils/sort-key-template.ts
-function sortKey(strings, ...keys) {
-  return (params) => {
-    let result = strings[0] ?? "";
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i];
-      if (key && params && key in params) {
-        result += params[key] + (strings[i + 1] ?? "");
-      }
-    }
-    return result;
-  };
-}
-
-export { sortKey };
-//# sourceMappingURL=sort-key-template.js.map
-//# sourceMappingURL=sort-key-template.js.map

package/dist/utils/sort-key-template.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/utils/sort-key-template.ts"],"names":[],"mappings":";AAqCO,SAAS,OAAA,CACd,YACG,IACkC,EAAA;AACrC,EAAA,OAAO,CAAC,MAAW,KAAA;AACjB,IAAI,IAAA,MAAA,GAAS,OAAQ,CAAA,CAAC,CAAK,IAAA,EAAA;AAE3B,IAAA,KAAA,IAAS,CAAI,GAAA,CAAA,EAAG,CAAI,GAAA,IAAA,CAAK,QAAQ,CAAK,EAAA,EAAA;AACpC,MAAM,MAAA,GAAA,GAAM,KAAK,CAAC,CAAA;AAElB,MAAI,IAAA,GAAA,IAAO,MAAU,IAAA,GAAA,IAAO,MAAQ,EAAA;AAClC,QAAA,MAAA,IAAU,OAAO,GAAG,CAAA,IAAK,OAAQ,CAAA,CAAA,GAAI,CAAC,CAAK,IAAA,EAAA,CAAA;AAAA;AAC7C;AAGF,IAAO,OAAA,MAAA;AAAA,GACT;AACF","file":"sort-key-template.js","sourcesContent":["export type GenerateType<T extends readonly string[], U extends string = never> = T extends [infer F, ...infer R]\n  ? F extends string\n    ? R extends string[]\n      ? ({ [K in F | U]: string | number } & Partial<Record<Exclude<T[number], F | U>, never>>) | GenerateType<R, F | U>\n      : never\n    : never\n  : never;\n\n/**\n * Creates a template function for generating DynamoDB sort keys with dynamic values.\n * Use this function when you need to:\n * - Create consistent sort key patterns with variable parts\n * - Generate sort keys that follow a specific format\n * - Ensure type safety for sort key parameters\n *\n * @example\n * ```ts\n * // Define a sort key template\n * const sk = sortKey`country#${\"country\"}#enclosure#${\"enclosure\"}#diet#${\"diet\"}`;\n *\n * // Generate a sort key with partial parameters\n * const templatedString = sk({ country: \"NZ\", enclosure: \"A1\" });\n * // Result: \"country#NZ#enclosure#A1#diet#\"\n *\n * // Generate a complete sort key\n * const fullKey = sk({ country: \"NZ\", enclosure: \"A1\", diet: \"carnivore\" });\n * // Result: \"country#NZ#enclosure#A1#diet#carnivore\"\n *\n * // Type checking ensures only valid parameters are used\n * const invalidKey = sk({ country: \"NZ\", invalid: \"value\" }); // TypeScript error\n * ```\n *\n * @param strings - The static parts of the template string\n * @param keys - The dynamic parts of the template string that will be replaced with values\n *\n * @returns A function that accepts an object with the dynamic values and returns the formatted sort key\n */\nexport function sortKey<T extends readonly string[]>(\n  strings: TemplateStringsArray,\n  ...keys: T\n): (params: GenerateType<T>) => string {\n  return (params) => {\n    let result = strings[0] ?? \"\";\n\n    for (let i = 0; i < keys.length; i++) {\n      const key = keys[i];\n\n      if (key && params && key in params) {\n        result += params[key] + (strings[i + 1] ?? \"\");\n      }\n    }\n\n    return result;\n  };\n}\n"]}