theauthapi 1.0.1 → 1.0.4

package/.eslintrc.js

@@ -0,0 +1,15 @@
+module.exports = {
+  root: true,
+  parser: '@typescript-eslint/parser',
+  plugins: [
+    '@typescript-eslint',
+  ],
+  extends: [
+    'eslint:recommended',
+    'plugin:@typescript-eslint/recommended',
+    'prettier'
+  ],
+  env: {
+    node: true
+  }
+};

package/.prettierrc.json

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

package/jest.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  setupFilesAfterEnv: ['./jest.setup.ts'],
+};

package/package.json

@@ -1,19 +1,16 @@
 {
   "name": "theauthapi",
-  "version": "1.0.1",
+  "version": "1.0.4",
   "description": "Client library for TheAuthAPI.com",
-  "main": "index.js",
-  
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {
-    "dependencies": "yarn",
-    "size": "size-limit",
-    "test": "standard && nyc ava",
-    "report-coverage": "nyc report --reporter=lcov > coverage.lcov && codecov",
+    "test": "jest --runInBand",
+    "test:coverage": "jest --coverage --runInBand",
     "np": "np --no-publish",
     "release": "yarn run np",
-    "babel-node": "babel-node --presets='@babel/preset-env'",
-    "dev": "nodemon --exec npm run babel-node -- src/app.js",
-    "test-mocha": "ava mocha"
+    "build": "tsc",
+    "prepublish": "npm run build"
   },
   "repository": {
     "type": "git",
@@ -29,31 +26,39 @@
     "assert": "^2.0.0",
     "axios": "^0.21.4",
     "axios-retry": "^3.1.9",
-    "core-js": "^3.17.3",
     "lodash.isstring": "^4.0.1",
+    "lodash.omit": "^4.5.0",
     "ms": "^2.1.3",
-    "node-cache": "^5.1.2",
-    "regenerator-runtime": "^0.13.9",
     "remove-trailing-slash": "^0.1.1"
   },
   "devDependencies": {
-    "ava": "^3.15.0",
-    "basic-auth": "^2.0.1",
-    "body-parser": "^1.17.1",
-    "chai": "^4.3.4",
-    "codecov": "^3.0.0",
-    "commander": "^5.1.0",
-    "delay": "^4.2.0",
+    "@size-limit/preset-small-lib": "^7.0.8",
+    "@types/basic-auth": "^1.1.3",
+    "@types/express": "^4.17.13",
+    "@types/jest": "^27.4.1",
+    "@types/lodash.isstring": "^4.0.6",
+    "@types/lodash.omit": "^4.5.6",
+    "@types/ms": "^0.7.31",
+    "@types/node": "^17.0.23",
+    "@typescript-eslint/eslint-plugin": "^5.17.0",
+    "@typescript-eslint/parser": "^5.17.0",
+    "body-parser": "^1.20.0",
+    "eslint": "^7.14.0",
+    "eslint-config-prettier": "^8.5.0",
     "express": "^4.15.2",
-    "husky": "^3.0.4",
-    "mocha": "^9.1.1",
-    "nyc": "^14.1.1",
-    "pify": "^4.0.1",
-    "sinon": "^7.3.2",
-    "sinon-chai": "^3.7.0",
+    "jest": "^27.5.1",
+    "prettier": "2.6.2",
     "size-limit": "^4.11.0",
-    "snyk": "^1.328.0",
-    "standard": "^12.0.1",
-    "supertest": "^6.1.6"
+    "ts-jest": "^27.1.4",
+    "ts-node": "^10.7.0",
+    "typescript": "^4.6.3"
+  },
+  "ava": {
+    "extensions": [
+      "ts"
+    ],
+    "require": [
+      "ts-node/register"
+    ]
   }
 }

package/src/endpoints/ApiKeys/ApiKeys.ts

@@ -0,0 +1,68 @@
+import { HttpMethod } from "../../services/ApiRequest/HttpMethod";
+import omit from "lodash.omit";
+import ApiRequest from "../../services/ApiRequest/ApiRequest";
+import {ApiKey, ApiKeyInput, UpdateApiKeyInput} from "../../types";
+import { validateString } from "../../util";
+import ApiKeysInterface from "./ApiKeysInterface";
+
+class ApiKeys implements ApiKeysInterface {
+  api: ApiRequest;
+
+  constructor(apiService: ApiRequest) {
+    this.api = apiService;
+  }
+
+  async authenticateKey(apikey: string) {
+    validateString("apikey", apikey);
+    return await this.api.request<ApiKey>(
+      HttpMethod.GET,
+      `/api-keys/${apikey}`
+    );
+  }
+
+  async getKeys(projectId: string) {
+    validateString("projectId", projectId);
+    return await this.api.request<ApiKey[]>(
+      HttpMethod.GET,
+      `/api-keys/?projectId=${projectId}`
+    );
+  }
+
+  async createKey(apiKey: ApiKeyInput) {
+    // validate string properties only
+    for (const [key, value] of Object.entries(
+      omit(apiKey, ["customMetaData", "rateLimitConfigs"])
+    )) {
+      validateString(key, value);
+    }
+    return await this.api.request<ApiKey>(
+      HttpMethod.POST,
+      "/api-keys",
+      apiKey
+    );
+  }
+
+  async updateKey(apiKey: string, updateTo: UpdateApiKeyInput) {
+    validateString("apiKey", apiKey);
+    for (const [key, value] of Object.entries(
+      omit(updateTo, "customMetaData")
+    )) {
+      validateString(key, value);
+    }
+    return await this.api.request<ApiKey>(
+      HttpMethod.PATCH,
+      `/api-keys/${apiKey}`,
+      updateTo
+    );
+  }
+
+  async deleteKey(apiKey: string) {
+    validateString("apiKey", apiKey);
+    return await this.api.request<boolean>(
+      HttpMethod.DELETE,
+      `/api-keys/${apiKey}`
+    );
+  }
+}
+
+export = ApiKeys;

package/src/endpoints/ApiKeys/ApiKeysInterface.ts

@@ -0,0 +1,11 @@
+import { ApiKey, ApiKeyInput, UpdateApiKeyInput } from "../../types";
+
+interface ApiKeysInterface {
+  authenticateKey(apiKey: string): Promise<ApiKey>;
+  getKeys(projectId: string): Promise<ApiKey[]>;
+  createKey(apiKey: ApiKeyInput): Promise<ApiKey>;
+  updateKey(apiKey: string, updateTo: UpdateApiKeyInput): Promise<ApiKey>;
+  deleteKey(apiKey: string): Promise<boolean>;
+}
+
+export = ApiKeysInterface;

package/src/endpoints/Projects/Projects.ts

@@ -0,0 +1,62 @@
+import ApiRequest from "../../services/ApiRequest/ApiRequest";
+import { Project, UpdateProjectInput } from "../../types";
+import { HttpMethod } from "../../services/ApiRequest/HttpMethod";
+import { validateString } from "../../util";
+import { ProjectsInterface } from "./ProjectsInterface";
+
+class Projects implements ProjectsInterface {
+  api: ApiRequest;
+  endpoint: string;
+
+  constructor(apiService: ApiRequest) {
+    this.api = apiService;
+    this.endpoint = "/projects";
+  }
+
+  async getProjects(accountId: string): Promise<Project[]> {
+    validateString("accountId", accountId);
+    return await this.api.request<Project[]>(
+      HttpMethod.GET,
+      `${this.endpoint}?accountId=${accountId}`
+    );
+  }
+
+  async getProject(projectId: string): Promise<Project> {
+    validateString("projectId", projectId);
+    return await this.api.request<Project>(
+      HttpMethod.GET,
+      `${this.endpoint}/${projectId}`
+    );
+  }
+
+  async deleteProject(projectId: string): Promise<boolean> {
+    validateString("projectId", projectId);
+    return await this.api.request<boolean>(
+      HttpMethod.DELETE,
+      `${this.endpoint}/${projectId}`
+    );
+  }
+
+  async createProject(name: string, accountId: string): Promise<Project> {
+    validateString("name", name);
+    validateString("accountId", accountId);
+    return await this.api.request<Project>(HttpMethod.POST, this.endpoint, {
+      name,
+      accountId,
+    });
+  }
+
+  async updateProject(
+    projectId: string,
+    updateTo: UpdateProjectInput
+  ): Promise<Project> {
+    validateString("projectId", projectId);
+    return this.api.request<Project>(
+      HttpMethod.PATCH,
+      `${this.endpoint}/${projectId}`,
+      updateTo
+    );
+  }
+}
+
+export default Projects;

package/src/endpoints/Projects/ProjectsInterface.ts

@@ -0,0 +1,9 @@
+import {Project, UpdateProjectInput} from "../../types";
+
+export interface ProjectsInterface {
+  getProjects(accountId: string): Promise<Project[]>;
+  getProject(projectId: string): Promise<Project>;
+  deleteProject(projectId: string): Promise<boolean>;
+  createProject(name: string, accountId: string): Promise<Project>;
+  updateProject(name: string, updateTo: UpdateProjectInput): Promise<Project>;
+}

package/src/index.ts

@@ -0,0 +1,103 @@
+import assert from "assert";
+import removeSlash from "remove-trailing-slash";
+
+import ApiRequest from "./services/ApiRequest/ApiRequest";
+import { validateString } from "./util";
+import ApiKeys from "./endpoints/ApiKeys/ApiKeys";
+import { HttpMethod } from "./services/ApiRequest/HttpMethod";
+import Projects from "./endpoints/Projects/Projects";
+
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+const noop = () => {};
+
+type Options = {
+  host?: string;
+  timeout?: string | number;
+  cacheTTL?: number;
+  enable?: boolean;
+  retryCount?: number;
+};
+
+class TheAuthAPI {
+  queue: [];
+  accessKey: string;
+  host: string;
+  timeout: number | string | undefined;
+  cacheTTL: number;
+  api: ApiRequest;
+  apiKeys: ApiKeys;
+  projects: Projects;
+
+  /**
+   * Initialize a new `Analytics` with your Segment project's `writeKey` and an
+   * optional dictionary of `options`.
+   *
+   * @param {String} accessKey
+   * @param {Object} [options] (optional)
+   *   @property {Number} flushAt (default: 20)
+   *   @property {Number} flushInterval (default: 10000)
+   *   @property {String} host (default: 'https://api.segment.io')
+   *   @property {Boolean} enable (default: true)
+   */
+
+  constructor(accessKey: string, options?: Options) {
+    assert(accessKey, "You must pass your project's write key.");
+    this.queue = [];
+    this.accessKey = accessKey;
+    this.host = removeSlash(options?.host || "https://api.theauthapi.com");
+    this.timeout = options?.timeout;
+    this.cacheTTL = options?.cacheTTL ?? 60;
+    this.api = new ApiRequest({
+      accessKey: this.accessKey,
+      host: this.host,
+    });
+    this.apiKeys = new ApiKeys(this.api);
+    this.projects = new Projects(this.api);
+
+    Object.defineProperty(this, "enable", {
+      configurable: false,
+      writable: false,
+      enumerable: true,
+      value: typeof options?.enable === "boolean" ? options.enable : true,
+    });
+  }
+
+  /*
+    @deprecated
+   */
+  async authenticateAPIKey(
+    key: string,
+    callback?: (err: any, data: any) => any
+  ) {
+    validateString("key", key);
+
+    const cb = callback || noop;
+    const done = (err: any) => {
+      cb(err, data);
+    };
+
+    const data = {
+      credentials: { api_key: key },
+      timestamp: new Date().getTime(),
+      sentAt: new Date().getTime(),
+    };
+
+    try {
+      const key = await this.api.request(
+        HttpMethod.POST,
+        "/auth/authenticate",
+        data
+      );
+      done(key);
+      return key;
+    } catch (err: any) {
+      if (err.response) {
+        const error = new Error(err.response.statusText);
+        return done(error);
+      }
+      done(err);
+    }
+  }
+}
+
+export default TheAuthAPI;

package/src/libraryMeta.ts

@@ -0,0 +1 @@
+export const version = "1.0.1";

package/src/services/ApiRequest/ApiCall.ts

@@ -0,0 +1,7 @@
+import {HttpMethod} from "./HttpMethod";
+
+interface ApiCall {
+  request<T>(method: HttpMethod, endpoint: string, payload?: any): Promise<T>
+}
+
+export = ApiCall;

package/src/services/ApiRequest/ApiRequest.ts

@@ -0,0 +1,132 @@
+import axios from "axios";
+import { version } from "../../libraryMeta";
+import { HttpMethod } from "./HttpMethod";
+import ApiCall from "./ApiCall";
+import ApiRequestError from "./ApiRequestError";
+import axiosRetry from "axios-retry";
+import ms from "ms";
+
+type Config = {
+  host: string;
+  accessKey: string;
+  headers?: object;
+  retryCount?: number;
+  timeout?: number | string;
+};
+
+class ApiRequest implements ApiCall {
+  host: string;
+  headers: object;
+  accessKey: string;
+  timeout: number;
+  retryCount: number;
+
+  constructor(config: Config) {
+    const { host, accessKey, headers, retryCount, timeout } = config;
+    this.host = host;
+    this.accessKey = accessKey;
+    this.headers = this._generateDefaultHeaders();
+    this.timeout = timeout ? (typeof timeout === "string" ? ms(timeout) : timeout) : 0;
+    this.retryCount = retryCount ?? 3;
+
+    if (headers) {
+      this.headers = { ...this.headers, headers };
+    }
+
+    this._init();
+  }
+
+  _init() {
+    const isoDateFormat = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d*)?(?:[-+]\d{2}:?\d{2}|Z)?$/
+    function isIsoDateString(value: any): boolean {
+      return value && typeof value === "string" && isoDateFormat.test(value);
+    }
+    function handleDates(body: any) {
+      if (body === null || body === undefined || typeof body !== "object"){
+        return body;
+      }
+      for (const key of Object.keys(body)) {
+        const value = body[key];
+        if (isIsoDateString(value)) {
+          body[key] = new Date(value);
+        } else if (typeof value === "object") {
+          handleDates(value);
+        }
+      }
+    }
+
+    axios.interceptors.response.use((response) => {
+      handleDates(response.data);
+      return response;
+    });
+
+    axiosRetry(axios, {
+      retries: this.retryCount ?? 3,
+      retryCondition: this._isErrorRetryable,
+      retryDelay: axiosRetry.exponentialDelay,
+    });
+  }
+
+  async request<T>(
+    method: HttpMethod,
+    endpoint: string,
+    payload?: any
+  ): Promise<T> {
+    try {
+      const response = await axios.request<T>({
+        baseURL: this.host,
+        method: method,
+        url: endpoint,
+        data: payload,
+        headers: this.headers,
+      });
+      return response.data;
+    } catch (error) {
+      if (axios.isAxiosError(error)) {
+        if (error.response) {
+          throw new ApiRequestError(
+            error.response.status,
+            error.response.data.message ?? error.response.statusText
+          );
+        } else if (error.request) {
+          throw new Error(error.request);
+        }
+      }
+      throw error;
+    }
+  }
+
+  _generateDefaultHeaders() {
+    return {
+      "user-agent": `theauthapi-client-node/${version}`,
+      "x-api-key": this.accessKey,
+      "api-key": this.accessKey,
+    };
+  }
+
+  _isErrorRetryable(error: any) {
+    // Retry Network Errors.
+    if (axiosRetry.isNetworkError(error)) {
+      return true;
+    }
+
+    if (!error.response) {
+      // Cannot determine if the request can be retried
+      return false;
+    }
+
+    // Retry Server Errors (5xx).
+    if (error.response.status >= 500 && error.response.status <= 599) {
+      return true;
+    }
+
+    // Retry if rate limited.
+    if (error.response.status === 429) {
+      return true;
+    }
+
+    return false;
+  }
+}
+
+export default ApiRequest;

package/src/services/ApiRequest/ApiRequestError.ts

@@ -0,0 +1,7 @@
+class ApiRequestError extends Error {
+  constructor(statusCode: number, message: string) {
+    super(`(${statusCode}): ${message}`);
+  }
+}
+
+export = ApiRequestError;

package/src/services/ApiRequest/HttpMethod.ts

@@ -0,0 +1,7 @@
+export enum HttpMethod {
+  GET = "GET",
+  POST = "POST",
+  DELETE = "DELETE",
+  PATCH = "PATCH",
+  PUT = "PUT",
+}

package/src/tests/endpoints/apiKeys.spec.ts

@@ -0,0 +1,102 @@
+import TheAuthAPI from "../../index";
+import testServer from "../testServer/server";
+import { Server } from "http";
+
+const port = 4063;
+
+const createClient = (options?: any) => {
+  options = Object.assign(
+    {
+      host: `http://localhost:${port}`,
+    },
+    options
+  );
+  return new TheAuthAPI("access_key", options);
+};
+
+describe("ApiKeys", () => {
+  let server: Server;
+  beforeAll(() => {
+    server = testServer.listen(port);
+  });
+
+  afterAll(() => {
+    server.close();
+  });
+
+  it("should authenticate a valid api-key", async () => {
+    const client = createClient();
+    const data = await client.apiKeys.authenticateKey(
+      "live_access_zBA6cvuEbJEUhhDIWwuErXHLnwvWqtcqe2ajfV3RVVZvD6lc6xDUaSsSZL1fk53a"
+    );
+    console.log('day', data.createdAt.getDate(), 'month', data.createdAt.getMonth())
+    expect(data.name).toEqual("My customers first Api Key");
+    expect(data.key).toEqual(
+      "KGTSsxbDndjRRcpJGuQQp2or9UmQkqRrVQpCWgQruIXnvnNatmfdmOTcsgYnNwnH"
+    );
+    expect(data.createdAt).toEqual(new Date("2022-03-16T10:34:23.353Z"));
+    expect(data.updatedAt).toEqual(new Date("2022-03-16T10:34:23.353Z"));
+    expect(data.env).toEqual("live");
+    expect(data.customAccountId).toEqual("acc-id");
+  });
+
+  it("should list api keys", async () => {
+    const client = createClient();
+    const keys = await client.apiKeys.getKeys("project_1");
+    expect(keys).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          key: "live_h3uDZInxQexGLkwoxMDmuqz6PsyXGjkbrmSTpEwFb8l97mdAlQKtt14kt9Rv91PL",
+          name: "my-first-api-key",
+          customMetaData: {},
+          customAccountId: null,
+          env: "live",
+        }),
+        expect.objectContaining({
+          key: "live_1OvRrfHbPdiCUrFAD4VwxiqEgg8L5uiVDlIgE4075juY7TnimZQG1Ll770irHyfM",
+          name: "my-second-api-key",
+          customMetaData: {},
+          customAccountId: null,
+          env: "live",
+        }),
+      ])
+    );
+  });
+
+  it("should create a key", async () => {
+    const client = createClient();
+    const key = await client.apiKeys.createKey({
+      name: "my-new-api-key1",
+      projectId: "b52262b5-eaa6-4edd-825c-ebcdf76a10e5",
+    });
+    expect(key).toEqual(
+      expect.objectContaining({
+        key: "live_1OvRrfHbPdiCUrFAD4VwxiqEgg8L5uiVDlIgE4075juY7TnimZQG1Ll770irHyfM",
+        name: "my-new-api-key1",
+        env: "live",
+      })
+    );
+  });
+
+  it("should update a key", async () => {
+    const client = createClient();
+    const key = await client.apiKeys.updateKey(
+      "live_TVHW0PVtktylIVObMd8J0sBHb7Ym3ZraObpeT3qxu7YRHig2KxrEIwggn50sBpSZ",
+      {
+        name: "my-first-update-key",
+      }
+    );
+    expect(key.name).toEqual("my-first-updated-key");
+    expect(key.key).toEqual(
+      "live_TVHW0PVtktylIVObMd8J0sBHb7Ym3ZraObpeT3qxu7YRHig2KxrEIwggn50sBpSZ"
+    );
+  });
+
+  it("should delete a key", async () => {
+    const client = createClient();
+    const response = await client.apiKeys.deleteKey(
+      "live_TVHW0PVtktylIVObMd8J0sBHb7Ym3ZraObpeT3qxu7YRHig2KxrEIwggn50sBpSZ"
+    );
+    expect(response).toBeTruthy();
+  });
+});