@creator.co/wapi 1.7.1-alpha4 → 1.7.1

package/.eslintignore

@@ -0,0 +1,3 @@
+node_modules
+dist
+smoke-tests

package/.eslintrc.cjs

@@ -0,0 +1,60 @@
+/* eslint-env node */
+module.exports = {
+  extends: [
+    'eslint:recommended',
+    'plugin:@typescript-eslint/recommended',
+    'plugin:prettier/recommended',
+    'plugin:import/recommended',
+    'plugin:import/typescript',
+  ],
+  parser: '@typescript-eslint/parser',
+  plugins: ['@typescript-eslint', 'prettier'],
+  root: true,
+  rules: {
+    'prettier/prettier': [
+      'error',
+      {
+        tabWidth: 2,
+        useTabs: false,
+        bracketSameLine: false,
+        semi: false,
+        arrowParens: 'avoid',
+        jsxSingleQuote: true,
+        printWidth: 100,
+        singleQuote: true,
+        quoteProps: 'as-needed',
+        htmlWhitespaceSensitivity: 'css',
+        proseWrap: 'preserve',
+        bracketSpacing: true,
+        embeddedLanguageFormatting: 'auto',
+        endOfLine: 'lf',
+        trailingComma: 'es5',
+      },
+    ],
+    '@typescript-eslint/ban-ts-comment': 0,
+    '@typescript-eslint/no-explicit-any': 0,
+    // turn on errors for missing imports
+    'import/no-unresolved': 'error',
+    // 'import/no-named-as-default-member': 'off',
+    'import/order': [
+      'error',
+      {
+        groups: [
+          'builtin', // Built-in imports (come from NodeJS native) go first
+          'external', // <- External imports
+          'internal', // <- Absolute imports
+          ['sibling', 'parent'], // <- Relative imports, the sibling and parent types they can be mingled together
+          'index', // <- index imports
+          'unknown', // <- unknown
+        ],
+        'newlines-between': 'always',
+        alphabetize: {
+          /* sort in ascending order. Options: ["ignore", "asc", "desc"] */
+          order: 'asc',
+          /* ignore case. Options: [true, false] */
+          caseInsensitive: true,
+        },
+      },
+    ],
+  },
+}

package/.github/workflows/npmpublish.yml

@@ -0,0 +1,11 @@
+name: NPM Publish
+on:
+  push: 
+    branches: [ "main", "gabe/tweaks" ]
+
+jobs:
+  Publish:
+    uses: Creator-co/tool-github-workflows/.github/workflows/npm-publish.yml@main
+    secrets: inherit
+    with:
+      NODE_VERSION: "20.x"

package/.github/workflows/prs.yml

@@ -0,0 +1,13 @@
+name: PR Checks
+on:
+  pull_request:
+    branches:
+      - master
+      - main
+
+jobs:
+  Checks:
+    uses: Creator-co/tool-github-workflows/.github/workflows/prs-check.yml@main
+    secrets: inherit
+    with:
+      NODE_VERSION: "20.x"

package/dist/package-lock.json

@@ -1,12 +1,12 @@
 {
     "name": "@creator.co/wapi",
-    "version": "1.7.1-alpha4",
+    "version": "1.7.1",
     "lockfileVersion": 3,
     "requires": true,
     "packages": {
         "": {
             "name": "@creator.co/wapi",
-            "version": "1.7.1-alpha4",
+            "version": "1.7.1",
             "license": "ISC",
             "dependencies": {
                 "@aws-sdk/client-kms": "^3.556.0",

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@creator.co/wapi",
-    "version": "1.7.1-alpha4",
+    "version": "1.7.1",
     "description": "",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",

package/jest.config.ts

@@ -0,0 +1,33 @@
+import type { Config } from '@jest/types'
+/* eslint-env node */
+const config: Config.InitialOptions = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  modulePathIgnorePatterns: ['smoke-tests'],
+  reporters: [
+    'default',
+    [
+      'jest-junit',
+      {
+        outputDirectory: 'coverage',
+        outputName: 'jest-junit.xml',
+        ancestorSeparator: ' › ',
+        uniqueOutputName: 'false',
+        suiteNameTemplate: '{filepath}',
+        classNameTemplate: '{classname}',
+        titleTemplate: '{title}',
+      },
+    ],
+  ],
+  coverageReporters: ['clover', 'json', 'lcov', ['text', { file: 'coverage.txt' }], 'json-summary'],
+  collectCoverageFrom: ['src/**/*.(t|j)s', '!src/**/*.d.(t|j)s'],
+  coverageThreshold: {
+    global: {
+      branches: 80,
+      functions: 80,
+      lines: 80,
+      statements: 80,
+    },
+  },
+}
+export default config

package/jest.smoke.config.ts

@@ -0,0 +1,35 @@
+import type { Config } from '@jest/types'
+/* eslint-env node */
+const config: Config.InitialOptions = {
+  testEnvironment: 'node',
+  // ECMA suppport https://jestjs.io/docs/ecmascript-modules
+  transform: {},
+
+  //
+  reporters: [
+    'default',
+    [
+      'jest-junit',
+      {
+        outputDirectory: 'coverage',
+        outputName: 'jest-junit.xml',
+        ancestorSeparator: ' › ',
+        uniqueOutputName: 'false',
+        suiteNameTemplate: '{filepath}',
+        classNameTemplate: '{classname}',
+        titleTemplate: '{title}',
+      },
+    ],
+  ],
+  coverageReporters: ['clover', 'json', 'lcov', ['text', { file: 'coverage.txt' }], 'json-summary'],
+  collectCoverageFrom: ['src/**/*.(t|j)s', '!src/**/*.d.(t|j)s'],
+  coverageThreshold: {
+    global: {
+      branches: 80,
+      functions: 80,
+      lines: 80,
+      statements: 80,
+    },
+  },
+}
+export default config

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@creator.co/wapi",
-  "version": "1.7.1-alpha4",
+  "version": "1.7.1",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/tests/API/Request.test.ts

@@ -0,0 +1,273 @@
+import { APIGatewayEvent, Context } from 'aws-lambda'
+import { expect } from 'chai'
+
+import Request, { HttpMethod } from '../../src/API/Request'
+import Logger from '../../src/Logger/Logger'
+
+function newReq(event: any, context?: any) {
+  const logger = new Logger(
+    {
+      logLevel: 'DEBUG',
+    },
+    '123-456'
+  )
+  return new Request<any, any, any>(
+    <APIGatewayEvent>(<unknown>event),
+    <Context>context ? context : {},
+    logger
+  )
+}
+
+describe('Request querystring', () => {
+  test('Null query string', () => {
+    const r = newReq({
+      queryStringParameters: null,
+    })
+    expect(r.containsQueryParam('123')).to.be.false
+    expect(r.getQueryParam('123')).to.be.null
+  })
+
+  test('Empty query string', () => {
+    const r = newReq({
+      queryStringParameters: {},
+    })
+    expect(r.containsQueryParam('123')).to.be.false
+    expect(r.getQueryParam('123')).to.be.null
+  })
+
+  test('Valid query string', () => {
+    const v = { '123': 'abc' }
+    const r = newReq({
+      queryStringParameters: v,
+    })
+    expect(r.containsQueryParam('123')).to.be.true
+    expect(r.getQueryParam('123')).to.be.equals('abc')
+    expect(r.getQueryParams()).to.be.deep.equal(v)
+  })
+
+  test('Valid query string number', () => {
+    const r = newReq({
+      queryStringParameters: { '123': 456 },
+    })
+    expect(r.containsQueryParam('123')).to.be.true
+    expect(r.getQueryParam('123')).to.be.equals(456)
+  })
+})
+
+describe('Request headers', () => {
+  test('Null headers', () => {
+    const r = newReq({ headers: null })
+    expect(r.getHeader('123')).to.be.null
+  })
+
+  test('Empty headers', () => {
+    const r = newReq({ headers: {} })
+    expect(r.getHeader('123')).to.be.null
+  })
+
+  test('Valid headers', () => {
+    const r = newReq({ headers: { '123': 'abc' } })
+    expect(r.getHeader('123')).to.be.equals('abc')
+  })
+
+  test('Auth headers', () => {
+    const r = newReq({ headers: { Authorization: 'abc' } })
+    expect(r.getAuthorizationHeader()).to.be.equals('abc')
+  })
+})
+
+describe('Request context', () => {
+  test('Null context', () => {
+    const r = newReq({ requestContext: null })
+    expect(r.getContextParam('123')).to.be.null
+  })
+
+  test('Empty context', () => {
+    const r = newReq({ requestContext: {} })
+    expect(r.getContextParam('123')).to.be.null
+  })
+
+  test('Valid context', () => {
+    const r = newReq({
+      requestContext: { '123': 'abc' },
+    })
+    expect(r.getContextParam('123')).to.be.equals('abc')
+  })
+})
+
+describe('Request path params', () => {
+  test('Null path params', () => {
+    const r = newReq({ pathParameters: null })
+    expect(r.containsPathParam('123')).to.be.false
+    expect(r.getPathParam('123')).to.be.null
+    expect(r.getPathParams()).to.be.null
+  })
+
+  test('Empty path params', () => {
+    const r = newReq({ pathParameters: {} })
+    expect(r.containsPathParam('123')).to.be.false
+    expect(r.getPathParam('123')).to.be.null
+    expect(r.getPathParams()).to.be.deep.equal({})
+  })
+
+  test('Valid path params', () => {
+    const v = { '123': 'abc' }
+    const r = newReq({
+      pathParameters: v,
+    })
+    expect(r.containsPathParam('123')).to.be.true
+    expect(r.getPathParam('123')).to.be.equals('abc')
+    expect(r.getPathParams()).to.be.deep.equal(v)
+  })
+
+  test('Valid path param number', () => {
+    const v = { '123': 456 }
+    const r = newReq({
+      pathParameters: v,
+    })
+    expect(r.containsPathParam('123')).to.be.true
+    expect(r.getPathParam('123')).to.be.equals(456)
+    expect(r.getPathParams()).to.be.deep.equal(v)
+  })
+
+  test('Fix path params', () => {
+    const v = { '123': 'abc' }
+    const r = newReq({ pathParameters: null })
+    r.setFixedPathParams(
+      Object.keys(v).map(k => ({ name: k })),
+      ['/'].concat(Object.values(v))
+    )
+    expect(r.containsPathParam('123')).to.be.true
+    expect(r.getPathParam('123')).to.be.equals('abc')
+    expect(r.getPathParams()).to.be.deep.equal(v)
+  })
+})
+
+describe('Request body', () => {
+  test('Null body', () => {
+    const r = newReq({ body: null })
+    expect(r.getBody()).to.be.null
+  })
+
+  test('Empty body', () => {
+    const r = newReq({ body: {} })
+    expect(r.getBody()).to.be.deep.equals({})
+  })
+
+  test('Empty string body', () => {
+    const r = newReq({ body: '{}' })
+    expect(r.getBody()).to.be.deep.equals({})
+  })
+
+  test('Broken json string body', () => {
+    const r = newReq({ body: '{name": "Joe"}' })
+    expect(r.getBody()).to.be.equals('{name": "Joe"}')
+  })
+
+  test('Valid string body', () => {
+    const r = newReq({ body: '{"name": "Joe"}' })
+    expect(r.getBody()).to.be.deep.equals({
+      name: 'Joe',
+    })
+  })
+
+  test('Valid json body', () => {
+    const r = newReq({ body: { name: 'Joe' } })
+    expect(r.getBody()).to.be.deep.equals({
+      name: 'Joe',
+    })
+  })
+})
+
+describe('Request path/method', () => {
+  test('Null path/method', () => {
+    const r = newReq({
+      path: null,
+      httpMethod: null,
+    })
+    expect(r.getPath()).to.be.null
+    expect(r.getMethod.bind(r)).to.throw('Invalid HTTP method: null')
+  })
+
+  test('Empty path/method', () => {
+    const r = newReq({
+      path: '',
+      httpMethod: '',
+    })
+    expect(r.getPath()).to.be.a('string')
+    expect(r.getPath()).to.be.equals('')
+    expect(r.getMethod.bind(r)).to.throw('Invalid HTTP method: ')
+  })
+
+  test('Valid method/path', () => {
+    const r = newReq({
+      path: '/root',
+      httpMethod: HttpMethod.GET,
+    })
+    expect(r.getPath()).to.be.a('string')
+    expect(r.getPath()).to.be.equals('/root')
+    expect(r.getMethod()).to.be.a('string')
+    expect(r.getMethod()).to.be.equals(HttpMethod.GET)
+  })
+
+  test('Case insensitive method', () => {
+    const r = newReq({
+      path: '/root',
+      httpMethod: 'poST',
+    })
+
+    expect(r.getMethod()).to.be.equals(HttpMethod.POST)
+  })
+})
+
+describe('Request ID', () => {
+  test('From context', () => {
+    const r = newReq({}, { awsRequestId: '123' })
+    expect(r.getRequestID()).to.not.be.null
+    expect(r.getRequestID()).to.be.equals('123')
+  })
+
+  test('From event', () => {
+    const r = newReq({
+      requestContext: { requestId: '123' },
+    })
+    expect(r.getRequestID()).to.not.be.null
+    expect(r.getRequestID()).to.be.equals('123')
+  })
+
+  test('unknown', () => {
+    const r = newReq({})
+    expect(r.getRequestID()).to.not.be.null
+    expect(r.getRequestID()).to.be.equals('unknown')
+  })
+})
+
+describe('Request origin IP', () => {
+  test('From context', () => {
+    const r = newReq({
+      requestContext: {
+        identity: { sourceIp: '127.0.0.1' },
+      },
+    })
+    expect(r.getOriginIP()).to.not.be.null
+    expect(r.getOriginIP()).to.be.equals('127.0.0.1')
+  })
+
+  test('From header', () => {
+    const r = newReq({
+      headers: {
+        'X-Forwarded-For': '127.0.0.1',
+      },
+    })
+    expect(r.getOriginIP()).to.not.be.null
+    expect(r.getOriginIP()).to.be.equals('127.0.0.1')
+  })
+
+  test('unknown', () => {
+    const r = newReq({})
+    expect(r.getOriginIP()).to.not.be.null
+    expect(r.getOriginIP()).to.be.equals('unknown')
+  })
+})
+
+export {}