@kravc/dos 1.12.5 → 2.0.0-alpha.0

package/src/Service/test/__tests__/firstItemGet.test.ts

@@ -0,0 +1,50 @@
+import { firstItemGet } from '../';
+
+describe('firstItemGet(items, attributeName, isUndefinedExpected)', () => {
+  const items = [
+    { id: '1', name: 'Alice', role: 'admin', nested: { value: 'test' } },
+    { id: '2', name: 'Bob', role: 'user' },
+  ];
+
+  describe('when isUndefinedExpected is false (default)', () => {
+    it('returns attribute value when first item exists and has the attribute', () => {
+      expect(firstItemGet(items, 'id')).toEqual('1');
+      expect(firstItemGet(items, 'name')).toEqual('Alice');
+      expect(firstItemGet(items, 'role')).toEqual('admin');
+    });
+
+    it('returns nested attribute value when first item has nested attribute', () => {
+      expect(firstItemGet(items, 'nested.value')).toEqual('test');
+    });
+
+    it('throws when first item is undefined (empty array)', () => {
+      expect(() => firstItemGet([], 'id')).toThrow();
+    });
+
+    it('throws when first item exists but attribute does not exist', () => {
+      expect(() => firstItemGet(items, 'missing')).toThrow();
+      expect(() => firstItemGet(items, 'nested.missing')).toThrow();
+    });
+  });
+
+  describe('when isUndefinedExpected is true', () => {
+    it('returns attribute value when first item exists and has the attribute', () => {
+      expect(firstItemGet(items, 'id', true)).toEqual('1');
+      expect(firstItemGet(items, 'name', true)).toEqual('Alice');
+      expect(firstItemGet(items, 'role', true)).toEqual('admin');
+    });
+
+    it('returns nested attribute value when first item has nested attribute', () => {
+      expect(firstItemGet(items, 'nested.value', true)).toEqual('test');
+    });
+
+    it('returns undefined when first item is undefined (empty array)', () => {
+      expect(firstItemGet([], 'id', true)).toBeUndefined();
+    });
+
+    it('returns undefined when first item exists but attribute does not exist', () => {
+      expect(firstItemGet(items, 'missing', true)).toBeUndefined();
+      expect(firstItemGet(items, 'nested.missing', true)).toBeUndefined();
+    });
+  });
+});

package/src/Service/test/__tests__/wait.test.ts

@@ -0,0 +1,66 @@
+import { wait } from '../';
+
+describe('wait(ms)', () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+  });
+
+  afterEach(() => {
+    jest.runOnlyPendingTimers();
+    jest.useRealTimers();
+  });
+
+  it('returns a Promise', () => {
+    expect(wait(100)).toBeInstanceOf(Promise);
+  });
+
+  it('resolves after specified milliseconds', async () => {
+    const promise = wait(100);
+    let resolved = false;
+
+    promise.then(() => {
+      resolved = true;
+    });
+
+    expect(resolved).toBe(false);
+    jest.advanceTimersByTime(99);
+    await Promise.resolve();
+    expect(resolved).toBe(false);
+    jest.advanceTimersByTime(1);
+    await Promise.resolve();
+    expect(resolved).toBe(true);
+  });
+
+  it('resolves when ms is 0', async () => {
+    const promise = wait(0);
+    let resolved = false;
+
+    promise.then(() => {
+      resolved = true;
+    });
+
+    expect(resolved).toBe(false);
+    jest.advanceTimersByTime(0);
+    await Promise.resolve();
+    expect(resolved).toBe(true);
+  });
+
+  it('handles different time durations correctly', async () => {
+    const promise1 = wait(50);
+    const promise2 = wait(200);
+    let resolved1 = false;
+    let resolved2 = false;
+
+    promise1.then(() => { resolved1 = true; });
+    promise2.then(() => { resolved2 = true; });
+
+    jest.advanceTimersByTime(50);
+    await Promise.resolve();
+    expect(resolved1).toBe(true);
+    expect(resolved2).toBe(false);
+
+    jest.advanceTimersByTime(150);
+    await Promise.resolve();
+    expect(resolved2).toBe(true);
+  });
+});

package/src/Service/test/createAccessToken.ts

@@ -0,0 +1,28 @@
+import { sign, type SignOptions } from 'jsonwebtoken';
+import { TEST_ISSUER, TEST_PRIVATE_KEY } from './keys';
+
+interface Options extends SignOptions {
+  exp?: string;
+  privateKey?: string;
+}
+
+/** Creates access token. */
+const createAccessToken = (options: Options, claims: Record<string, unknown>) => {
+  const {
+    issuer = TEST_ISSUER,
+    algorithm = 'RS256',
+    privateKey = TEST_PRIVATE_KEY,
+    ...signOptions
+  } = options;
+
+  const payload = {
+    sub: 'TEST_USER_ID',
+    ...claims
+  };
+
+  const token = sign(payload, privateKey, { algorithm, issuer, ...signOptions });
+
+  return `Bearer ${token}`;
+};
+
+export default createAccessToken;

package/src/Service/test/ensureItem.ts

@@ -0,0 +1,9 @@
+import findItem, { type Items, type Query } from './findItem';
+
+/** Ensures item to exists in a list for specified query. */
+const ensureItem = (items: Items, query: Query) => {
+  const item = findItem(items, query);
+  expect(item).toBeDefined();
+};
+
+export default ensureItem;

package/src/Service/test/ensureNoItem.ts

@@ -0,0 +1,9 @@
+import findItem, { type Items, type Query } from './findItem';
+
+/** Ensures item does not exist in a list for specified query. */
+const ensureNoItem = (data: Items, query: Query) => {
+  const item = findItem(data, query);
+  expect(item).toBeUndefined();
+};
+
+export default ensureNoItem;

package/src/Service/test/execute.ts

@@ -0,0 +1,112 @@
+import Service from '../Service';
+import { type ErrorAttributes } from '../errors';
+import type { Headers, MutationMap, LambdaRequest, Logger } from '../../Context';
+
+const SUCCESS_HTTP_CODES = [ 200, 201, 204 ];
+const NO_RESPONSE_HTTP_CODE = 204;
+
+type Parameters = {
+  mutation?: MutationMap;
+  [index: string]: unknown;
+}
+
+type SuccessResult = { data: Record<string, unknown>; };
+type ErrorResult = { error: ErrorAttributes; };
+type Result = SuccessResult | ErrorResult;
+
+type Options = {
+  logger?: Logger
+};
+
+/** Returns helpers to process requests successfully or expect an error. */
+const execute = (service: Service, options: Options = {}) => {
+  const { logger = console } = options;
+
+  /** Processes an operation parameters via service. */
+  const exec = async (operationId: string, parameters: Parameters = {}, headers: Headers = {}) => {
+    const { mutation: body, ...queryStringParameters } = parameters;
+
+    const request = {
+      body,
+      headers,
+      operationId,
+      queryStringParameters
+    } as LambdaRequest;
+
+    const response = await service.process(request);
+
+    let result;
+
+    if (response.body) {
+      result = JSON.parse(response.body) as Result;
+    }
+
+    return { ...response, result };
+  };
+
+  /** Processes an operation parameters via service, expects successfull response. */
+  const request = async (operationId: string, parameters: Parameters = {}, headers: Headers = {}) => {
+    const {
+      result,
+      statusCode,
+    } = await exec(operationId, parameters, headers);
+
+    let data;
+
+    const isResultExpected = statusCode !== NO_RESPONSE_HTTP_CODE;
+
+    if (isResultExpected) {
+      data = (result as SuccessResult).data;
+    }
+
+    const isSuccess = SUCCESS_HTTP_CODES.includes(statusCode);
+
+    if (!isSuccess) {
+       const { error } = (result as ErrorResult);
+
+      logger.error(`\x1b[31mRequestError for "${operationId}"\x1b[37m`);
+      logger.dir({ operationId, parameters, error }, { depth: null });
+
+      throw Error(`RequestError for "${operationId}"`);
+    }
+
+    return data;
+  };
+
+  /** Processes an operation parameters via service, expects an error with a specific code. */
+  const expectError = async (errorCode: string, operationId: string, parameters: Parameters = {}, headers: Headers = {}) => {
+    const {
+      result,
+      statusCode,
+    } = await exec(operationId, parameters, headers);
+
+    const isSuccess = SUCCESS_HTTP_CODES.includes(statusCode);
+
+    if (isSuccess) {
+      const { data } = (result as SuccessResult);
+
+      logger.error(`\x1b[31mSuccess NOT expected for "${operationId}"\x1b[37m`);
+      logger.dir({ operationId, statusCode, parameters, data }, { depth: null });
+
+      throw Error(`Success NOT expected for "${operationId}"`);
+    }
+
+    const { error } = (result as ErrorResult);
+
+    const isExpectedCode = error.code === errorCode;
+
+    if (!isExpectedCode) {
+      throw Error(`Unexpected error code received "${error.code}", expected "${errorCode}"`);
+    }
+
+    return error;
+  };
+
+  return {
+    exec,
+    request,
+    expectError,
+  };
+};
+
+export default execute;

package/src/Service/test/findItem.ts

@@ -0,0 +1,22 @@
+export type Item = Record<string, unknown>;
+export type Items = Item[];
+export type Query = Record<string, unknown>;
+
+/** Finds item in a list using query. */
+const findItem = (items: Items, query: Query): Item | undefined =>
+  items.find(item => {
+    for (const key in query) {
+      const queryValue = query[key];
+      const itemValue = item[key];
+
+      const isMatch = itemValue === queryValue;
+
+      if (!isMatch) {
+        return false;
+      }
+    }
+
+    return true;
+  });
+
+export default findItem;

package/src/Service/test/firstItemGet.ts

@@ -0,0 +1,18 @@
+import { get } from 'lodash';
+import { got } from '@kravc/schema';
+import { type Items } from './findItem';
+
+/** Returns value or ensures specified attribute exists for the first item from the list. */
+const firstItemGet = (items: Items, attributeName: string, isUndefinedExpected: boolean = false) => {
+  const [ firstItem ] = items;
+
+  if (isUndefinedExpected) {
+    return get(firstItem || {}, attributeName);
+  }
+
+  expect(firstItem).toBeDefined();
+
+  return got(firstItem, attributeName);
+};
+
+export default firstItemGet;

package/src/Service/test/index.ts

@@ -0,0 +1,19 @@
+import wait from './wait';
+import execute from './execute';
+import findItem from './findItem';
+import ensureItem from './ensureItem';
+import ensureNoItem from './ensureNoItem';
+import firstItemGet from './firstItemGet';
+import createAccessToken from './createAccessToken';
+
+export {
+  wait,
+  execute,
+  findItem,
+  ensureItem,
+  ensureNoItem,
+  firstItemGet,
+  createAccessToken
+};
+
+export * from './keys';

package/src/Service/test/keys.ts

@@ -0,0 +1,75 @@
+const TEST_ISSUER = 'http://localhost:3000';
+
+const TEST_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
+MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA8+PZ2JWhsb9kwI4gdEhr
+xaRimI6p/zYgYY9pb16wmiR5T2JaStWJU0Whbd8SImqgNPpNUkBhjMU1gY2rdYDr
+K1vLyYcOrF6dZs50LzTZkxr6siWARYIOfgKKm+zfESNR2LhT+846pAwgjyzTfIri
+E5astLrUtrHoDCH0kvUEBgWREDwNpOsDcuWdt/9J50rVKlIar5XhfPxN0ZPqkb4F
+UnZXOwbE4yHEUcafXwnEAJ+e7nRMSAkTUQahN722xdZKYSeATSvANIAr64CH3Cxv
+vHWDt7ZJUJ1wgRWmkyqOkJu+NwnNhVBLt/6KacMkdXLDJhq7KnOFOmGLqUIPEY2F
+yFGahicWYoZiYCLli/XknzZRtmKjXrwvbIE6tx5lF/+RwD75Y4j057SHwDkvA/G7
+aBMvcCBYMnRRuJnsnGf8hXwjbdjvbjx3S3NQU/nOumEuPEjSmm92WrnLXLfmVVrv
+AImtxiAZWQi/EKVion96g3rTpirbbpp11+8JIlcy0cKZFNN3Vwfw2JmsG5srBEqz
+0S7s7ybuMPiRpD+NcxmSzbZt4qpgBDKJe71J0P6tzeca2SS7JuhUYwVdakiLKQT6
+MKZT4sNBcn2mY/lYRNn3iw5Tc1mZ8Ou3EWwzR4uJUyyp1EUjvDjAT7vWauFrz1gW
+eknx7j5GYy4QAZMQXsXCS80CAwEAAQ==
+-----END PUBLIC KEY-----`;
+
+const TEST_PRIVATE_KEY = `-----BEGIN PRIVATE KEY-----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+-----END PRIVATE KEY-----`;
+
+export {
+  TEST_ISSUER,
+  TEST_PUBLIC_KEY,
+  TEST_PRIVATE_KEY,
+};

package/src/Service/test/wait.ts

@@ -0,0 +1,5 @@
+
+/** Pause execution for a specified number of milliseconds. */
+const wait = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
+
+export default wait;

package/src/Service/useComposerMiddleware.ts

@@ -0,0 +1,56 @@
+import { sync } from 'read-yaml-file';
+import type { Context } from '../Context';
+import { OK_STATUS, JSON_TYPE } from './useOasMiddleware';
+
+const ROOT_PATH = process.cwd();
+
+const COMPOSER_FILES = [
+  '/Enums.yaml',
+  '/Schemas.yaml',
+  '/Documents.yaml',
+  '/Scenarios.yaml',
+  '/Operations.yaml',
+  '/Parameters.yaml'
+];
+
+/** Returns result if request is for service composer file. */
+const useComposerMiddleware = (_service: unknown, context: Context) => {
+  const {
+    httpPath,
+    httpMethod,
+    isDevelopment
+  } = context;
+
+  const isGetRequest = httpMethod === 'get';
+
+  /** Returns specified composer source file. */
+  const readFileJson = (httpPath: string) => {
+    const fileName = httpPath.replace('/', '');
+    const composerSource = sync(`${ROOT_PATH}/.composer/${fileName}`);
+
+    return JSON.stringify(composerSource, null, 2);
+  };
+
+  const isComposerPath = COMPOSER_FILES.includes(httpPath);
+
+  const shouldReturnComposerSource =
+    isDevelopment &&
+    isGetRequest &&
+    isComposerPath;
+
+  if (!shouldReturnComposerSource) {
+    return null;
+  }
+
+  const bodyJson = readFileJson(httpPath);
+
+  return {
+    headers: {
+      'Content-Type': JSON_TYPE
+    },
+    statusCode: OK_STATUS,
+    body: bodyJson,
+  };
+};
+
+export default useComposerMiddleware;

package/src/Service/useOasMiddleware.ts

@@ -0,0 +1,69 @@
+import { resolve } from 'path';
+import { Context } from '../Context';
+import { OpenAPIV2 } from 'openapi-types';
+import getServiceInfo from './spec/getServiceInfo';
+import { readFileSync } from 'fs';
+
+const SWAGGER_UI_TEMPLATE_PATH = resolve(__dirname, '../../assets/index.html');
+const SWAGGER_UI_TEMPLATE = readFileSync(SWAGGER_UI_TEMPLATE_PATH, { encoding: 'utf8' });
+
+const TEXT_TYPE = 'text/html; charset=UTF-8';
+export const JSON_TYPE = 'application/json; charset=utf-8';
+export const OK_STATUS = 200;
+
+/** Returns result if request is for service specification file. */
+const useOasMiddleware = ({ spec }: { spec: OpenAPIV2.Document; }, context: Context) => {
+  const {
+    httpPath,
+    httpMethod,
+    isDevelopment
+  } = context;
+
+  const isGetRequest = httpMethod === 'get';
+
+  const isRootPath = httpPath === '/';
+
+  const shouldReturnBody =
+    isRootPath &&
+    isGetRequest;
+
+  if (shouldReturnBody) {
+    const bodyText = isDevelopment
+      ? SWAGGER_UI_TEMPLATE.replace('$TITLE', getServiceInfo().title)
+      : 'healthy';
+
+    return {
+      headers: {
+        'Content-Type': TEXT_TYPE
+      },
+      statusCode: OK_STATUS,
+      body: bodyText,
+    };
+  }
+
+  const isSpecPath = httpPath.toLowerCase() === '/spec';
+
+  const shouldReturnSpec =
+    isSpecPath &&
+    isGetRequest;
+
+  if (shouldReturnSpec) {
+    const body = isDevelopment
+      ? spec
+      : { info: getServiceInfo() };
+
+    const bodyJson = JSON.stringify(body, null, 2);
+
+    return {
+      headers: {
+        'Content-Type': JSON_TYPE
+      },
+      statusCode: OK_STATUS,
+      body: bodyJson,
+    };
+  }
+
+  return null;
+};
+
+export default useOasMiddleware;

package/src/index.ts

@@ -0,0 +1,12 @@
+import { got } from '@kravc/schema';
+export { got };
+
+export * from './Component';
+export * from './Document';
+export * from './Operation';
+export * from './Service';
+export * from './Context';
+
+export type * from './Context';
+export type * from './Document';
+export type * from './Operation';

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "rootDir": "./src",
+    "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"
+  ]
+}

package/examples/CreateProfile.js

@@ -1,40 +0,0 @@
-'use strict'
-
-const Create           = require('../src/operations/Create')
-const Profile          = require('./Profile')
-const verifyToken      = require('../src/security/verifyToken')
-const { publicKey }    = require('../src/test/keys')
-const JwtAuthorization = require('../src/security/JwtAuthorization')
-
-class CreateProfile extends Create(Profile) {
-  static get tags() {
-    return [
-      'Profiles',
-      'profiles-write',
-      'System'
-    ]
-  }
-
-  static get security() {
-    const algorithm = 'RS256'
-
-    const accessVerificationMethod = (context, { group }) => {
-      const isAccessGranted = [ 'Administrators' ].includes(group)
-
-      return [ isAccessGranted, 'Access denied' ]
-    }
-
-    const tokenVerificationMethod = (...args) => verifyToken(...args)
-
-    return [
-      JwtAuthorization.createRequirement({
-        publicKey,
-        algorithm,
-        tokenVerificationMethod,
-        accessVerificationMethod
-      })
-    ]
-  }
-}
-
-module.exports = CreateProfile

package/examples/DeleteProfile.js

@@ -1,6 +0,0 @@
-'use strict'
-
-const Delete  = require('../src/operations/Delete')
-const Profile = require('./Profile')
-
-module.exports = Delete(Profile)

package/examples/Health.js

@@ -1,8 +0,0 @@
-'use strict'
-
-const { Operation } = require('../src')
-
-class Health extends Operation {
-}
-
-module.exports = Health

package/examples/IndexProfiles.js

@@ -1,6 +0,0 @@
-'use strict'
-
-const Index   = require('../src/operations/Index')
-const Profile = require('./Profile')
-
-module.exports = Index(Profile)

package/examples/Profile.js

@@ -1,8 +0,0 @@
-'use strict'
-
-const { Document } = require('../src')
-
-class Profile extends Document {
-}
-
-module.exports = Profile

package/examples/Profile.yaml

@@ -1,4 +0,0 @@
-id:
-  required: true
-
-name: {}