@kravc/dos-dynamodb 1.0.0-alpha.0

package/src/Table/helpers/filterConditionExpression.ts

@@ -0,0 +1,87 @@
+import { get } from 'lodash';
+import type { QueryMap } from '@kravc/dos';
+import { ExpressionKey } from './buildConditionExpression';
+
+/** Ensures item matches condition expression built from a query. */
+function filterConditionExpression<T>(item: T, query: QueryMap): T | undefined {
+  if (!item) {
+    return;
+  }
+
+  const conditionEntries = Object.entries(query);
+
+  for (const [key, value] of conditionEntries) {
+    const isNot = key.endsWith(`:${ExpressionKey.NOT}`);
+    const isContains = key.endsWith(`:${ExpressionKey.CONTAIN}`);
+    // const isLessThan    = key.endsWith(':lt')
+    // const isGreaterThan = key.endsWith(':gt')
+    const isNotContains = key.endsWith(`:${ExpressionKey.EXCLUDE}`);
+
+    const isFilterValueArray = Array.isArray(value);
+
+    const isFilterValueNull = value === null;
+
+    let path = key;
+    /** Checks items are equal. */
+    let match = (a: unknown, b: unknown) => a === b;
+
+    if (isNot) {
+      path = key.replace(/:not/g, '');
+
+      /** Checks items are not equal. */
+      match = (a: unknown, b: unknown) => a !== b;
+    }
+
+    if (isFilterValueNull) {
+      if (isNot) {
+        /** Checks item is not undefined. */
+        match = (a) => a !== undefined;
+
+      } else {
+        /** Checks item is undefined. */
+        match = (a) => a === undefined;
+
+      }
+    }
+
+    if (isContains) {
+      path = key.replace(/:contains/g, '');
+
+      /** Checks item includes value. */
+      match = (a: unknown, b: unknown) => (a as unknown[]).includes(b);
+    }
+
+    if (isNotContains) {
+      path = key.replace(/:not_contains/g, '');
+
+      /** Checks item does not include value. */
+      match = (a: unknown, b: unknown) => !(a as unknown[]).includes(b);
+    }
+
+    if (isFilterValueArray) {
+      /** Checks item is included in the array. */
+      match = (a: unknown, b: unknown) => (b as unknown[]).includes(a);
+    }
+
+    // if (isLessThan) {
+    //   path = key.replace(/:lt/g, '')
+    // }
+
+    // if (isGreaterThan) {
+    //   path = key.replace(/:gt/g, '')
+    // }
+
+    const itemValue = get(item, path);
+    const isMatched = match(itemValue, value);
+
+    if (isMatched) {
+      continue;
+    }
+
+    return;
+  }
+
+  return item;
+};
+
+export default filterConditionExpression;

package/src/Table/helpers/getRawClientConfig.ts

@@ -0,0 +1,35 @@
+import { homedir } from 'os';
+import { fromIni } from '@aws-sdk/credential-providers';
+import { existsSync } from 'fs';
+import { LOCAL_REGION } from './getTableOptions';
+import { type DynamoDBClientConfig } from '@aws-sdk/client-dynamodb';
+
+const HOME = homedir();
+const hasAwsCredentials = existsSync(`${HOME}/.aws/credentials`);
+
+const LOCAL_ENDPOINT = 'http://0.0.0.0:8000';
+const DEFAULT_MAX_ATTEMPTS = 10;
+
+/** Returns config for DynamoDB raw client. */
+const getRawClientConfig = (region: string, profile: string): DynamoDBClientConfig => {
+  const config = {
+    maxAttempts: DEFAULT_MAX_ATTEMPTS,
+    region,
+  } as DynamoDBClientConfig;
+
+  const isLocal = region === LOCAL_REGION;
+
+  /* istanbul ignore else */
+  if (isLocal) {
+    config.endpoint = LOCAL_ENDPOINT;
+  }
+
+  /* istanbul ignore else */
+  if (hasAwsCredentials) {
+    config.credentials = fromIni({ profile });
+  }
+
+  return config;
+};
+
+export default getRawClientConfig;

package/src/Table/helpers/getTableOptions.ts

@@ -0,0 +1,228 @@
+import config from 'config';
+import { got } from '@kravc/dos';
+import { get } from 'lodash';
+import { join } from 'node:path';
+import { readFileSync } from 'node:fs';
+
+export const LOCAL_REGION = 'local';
+const PRIVATE_PROFILE = 'private';
+
+export type LSI = {
+  name: string;
+  sortKey: string;
+};
+
+export type GSI = {
+  name: string;
+  partitionKey: string;
+  sortKey: string;
+};
+
+export type PrimaryKey = {
+  sortKey: string;
+  partitionKey: string;
+};
+
+export type LocalIndexKeyComposer = { documentName: string, sk: string };
+export type GlobalIndexKeyComposer = { pk: string, sk?: string };
+
+type LocalIndexProps = {
+  indexName: string;
+  sortKeyName: string;
+};
+
+type GlobalIndexProps = {
+  indexName: string;
+  sortKeyName: string;
+  partitionKeyName: string;
+};
+
+export type TableOptions = {
+  name: string;
+  region: string;
+  profile: string;
+  indexKeys: Record<string, LocalIndexKeyComposer | Record<string, GlobalIndexKeyComposer>>;
+  primaryKey: PrimaryKey;
+  isLocalhost: boolean;
+  localSecondaryIndexes: LSI[];
+  globalSecondaryIndexes: GSI[];
+  getLocalIndexSortKeyName: (indexName: string) => string;
+  getGlobalIndexPartitionKeyName: (indexName: string) => string;
+  getGlobalIndexSortKeyName: (indexName: string) => string;
+  isLocalSecondaryIndex: (indexName: string) => boolean;
+  getLocalIndexProps: (indexName: string) => LocalIndexProps;
+  getGlobalIndexProps: (indexName: string) => GlobalIndexProps;
+}
+
+/** Returns default table name. */
+const getDefaultName = (): string => {
+  const ROOT_PATH = process.cwd();
+  const { NODE_APP_INSTANCE } = process.env;
+
+  const { name } = JSON.parse(
+    readFileSync(join(ROOT_PATH, 'package.json'), 'utf-8')
+  ) as { name: string; };
+
+  const prefix = name.replace('@', '').replace('/', '-');
+
+  return [ prefix, NODE_APP_INSTANCE ].filter(value => !!value).join('-');
+};
+
+/** Returns options for DynamoDB table creation. */
+const getTableOptions = (partitionKey: string, sortKey: string): TableOptions => {
+  const tableConfig = config.get('dynamodb');
+  const tableOptions = JSON.parse(JSON.stringify(tableConfig)) as TableOptions;
+
+  const name = get(tableConfig, 'name', getDefaultName());
+  const indexKeys = get(tableConfig, 'indexKeys', {});
+
+  const region = get(config, 'aws.region', LOCAL_REGION);
+  const profile = get(config, 'aws.profile', PRIVATE_PROFILE);
+
+  const primaryKey = {
+    sortKey,
+    partitionKey,
+  };
+
+  tableOptions.name = name;
+  tableOptions.region = region;
+  tableOptions.profile = profile;
+  tableOptions.indexKeys = indexKeys;
+  tableOptions.primaryKey = primaryKey;
+  tableOptions.isLocalhost = region === LOCAL_REGION;
+
+  tableOptions.localSecondaryIndexes = get(config, 'localSecondaryIndexes', [
+    {
+      name: 'lsi1',
+      sortKey: '_lsi1SortKey',
+    },
+    {
+      name: 'lsi2',
+      sortKey: '_lsi2SortKey',
+    },
+    {
+      name: 'lsi3',
+      sortKey: '_lsi3SortKey',
+    },
+  ]) as LSI[];
+
+  tableOptions.globalSecondaryIndexes = get(config, 'globalSecondaryIndexes', [
+    {
+      name: 'gsi1',
+      partitionKey: '_gsi1PartitionKey',
+      sortKey: '_gsi1SortKey',
+    },
+    {
+      name: 'gsi2',
+      partitionKey: '_gsi2PartitionKey',
+      sortKey: '_gsi2SortKey',
+    },
+    {
+      name: 'gsi3',
+      partitionKey: '_gsi3PartitionKey',
+      sortKey: '_gsi3SortKey',
+    },
+  ]) as GSI[];
+
+  /** Returns sort key name for a local secondary index. */
+  const getLocalIndexSortKeyName = (indexName: string): string => {
+    const { localSecondaryIndexes } = tableOptions;
+
+    const index = localSecondaryIndexes.find(({ name }) => name === indexName);
+    const indexesJson = JSON.stringify(localSecondaryIndexes, null, 2);
+
+    if (!index) {
+      throw new Error(`Local secondary index "${indexName}" is not defined, local indexes: ${indexesJson}`);
+    }
+
+    return got(index, 'sortKey') as string;
+  };
+
+  /** Returns partition key name for a global secondary index. */
+  const getGlobalIndexPartitionKeyName = (indexName: string): string => {
+    const { globalSecondaryIndexes } = tableOptions;
+
+    const index = globalSecondaryIndexes.find(({ name }) => name === indexName);
+    const indexesJson = JSON.stringify(globalSecondaryIndexes, null, 2);
+
+    if (!index) {
+      throw new Error(`Global secondary index "${indexName}" is not defined, global indexes: ${indexesJson}`);
+    }
+
+    return got(index, 'partitionKey') as string;
+  };
+
+  /** Returns sort key name for a global secondary index. */
+  const getGlobalIndexSortKeyName = (indexName: string): string => {
+    const { globalSecondaryIndexes } = tableOptions;
+
+    const index = globalSecondaryIndexes.find(({ name }) => name === indexName);
+    const indexesJson = JSON.stringify(globalSecondaryIndexes, null, 2);
+
+    if (!index) {
+      throw new Error(`Global secondary index "${indexName}" is not defined, global indexes: ${indexesJson}`);
+    }
+
+    return got(index, 'sortKey') as string;
+  };
+
+  /** Returns true if local secondary index, false if global secondary index; throws if not found. */
+  const isLocalSecondaryIndex = (indexName: string): boolean => {
+    const {
+      localSecondaryIndexes,
+      globalSecondaryIndexes
+    } = tableOptions;
+
+    const lsi = localSecondaryIndexes.find(({ name }) => name === indexName);
+
+    if (lsi) {
+      return true;
+    }
+
+    const gsi = globalSecondaryIndexes.find(({ name }) => name === indexName);
+
+    if (gsi) {
+      return false;
+    }
+
+    const indexesJson = JSON.stringify({ localSecondaryIndexes, globalSecondaryIndexes }, null, 2);
+    throw new Error(`Index "${indexName}" is not defined, indexes: ${indexesJson}`);
+  };
+
+  /** Returns props for a local index by name. */
+  const getLocalIndexProps = (indexName: string): LocalIndexProps => {
+    isLocalSecondaryIndex(indexName);
+
+    const sortKeyName = getLocalIndexSortKeyName(indexName);
+
+    return {
+      indexName,
+      sortKeyName,
+    };
+  };
+
+  /** Returns props for a global index by name. */
+  const getGlobalIndexProps = (indexName: string): GlobalIndexProps => {
+    isLocalSecondaryIndex(indexName);
+
+    const sortKeyName = getGlobalIndexSortKeyName(indexName);
+    const partitionKeyName = getGlobalIndexPartitionKeyName(indexName);
+
+    return {
+      indexName,
+      sortKeyName,
+      partitionKeyName,
+    };
+  };
+
+  tableOptions.getLocalIndexSortKeyName = getLocalIndexSortKeyName;
+  tableOptions.getGlobalIndexPartitionKeyName = getGlobalIndexPartitionKeyName;
+  tableOptions.getGlobalIndexSortKeyName = getGlobalIndexSortKeyName;
+  tableOptions.isLocalSecondaryIndex = isLocalSecondaryIndex;
+  tableOptions.getGlobalIndexProps = getGlobalIndexProps;
+  tableOptions.getLocalIndexProps = getLocalIndexProps;
+
+  return tableOptions;
+};
+
+export default getTableOptions;

package/src/Table/helpers/index.ts

@@ -0,0 +1,21 @@
+import buildTableSchema from './buildTableSchema';
+import getRawClientConfig from './getRawClientConfig';
+import buildUpdateExpression from './buildUpdateExpression';
+import buildQueryCommandInput from './buildQueryCommandInput';
+import buildConditionExpression from './buildConditionExpression';
+import filterConditionExpression from './filterConditionExpression';
+import getTableOptions, { type TableOptions } from './getTableOptions';
+
+export {
+  getTableOptions,
+  buildTableSchema,
+  getRawClientConfig,
+  buildUpdateExpression,
+  buildQueryCommandInput,
+  buildConditionExpression,
+  filterConditionExpression,
+};
+
+export type {
+  TableOptions,
+};

package/src/Table/index.ts

@@ -0,0 +1,18 @@
+import { ExpressionKey } from './helpers/buildConditionExpression';
+import { SortExpressionKey } from './helpers/buildQueryConditionExpression';
+import Table, { type ItemAttributes } from './Table';
+import type { TableOptions, LocalIndexKeyComposer, GlobalIndexKeyComposer } from './helpers/getTableOptions';
+
+export default Table;
+
+export {
+  ExpressionKey,
+  SortExpressionKey,
+};
+
+export type {
+  TableOptions,
+  ItemAttributes,
+  LocalIndexKeyComposer,
+  GlobalIndexKeyComposer
+};

package/src/index.ts

@@ -0,0 +1,15 @@
+import Document from './Document/Document';
+import DocumentWithHashId from './Document/DocumentWithHashId';
+import type { DefaultAttributes } from './Document/DefaultAttributes';
+import { ExpressionKey, SortExpressionKey } from './Table';
+
+export {
+  Document,
+  ExpressionKey,
+  SortExpressionKey,
+  DocumentWithHashId,
+};
+
+export type {
+  DefaultAttributes,
+};

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "rootDir": "./",
+    "outDir": "./dist",
+    "target": "esnext",
+    "module": "nodenext",
+    "isolatedModules": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "strictNullChecks": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": [
+    "src"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "**/*.test.ts"
+  ]
+}