theauthapi 1.0.3 → 1.0.6

package/README.md

@@ -1,2 +1,5 @@
-# theauthapi
-Client library for TheAuthAPI.com
+# The Auth API node library
+## Scalable API Key Management and Auth Control
+## Secure your API with best in class API Key management, user access, all with great analytics.
+
+Client library for [TheAuthAPI.com](https://theauthapi.com)

package/dist/endpoints/Accounts/Accounts.d.ts

@@ -0,0 +1,10 @@
+import { AccountsInterface } from "./AccountsInterface";
+import ApiRequest from "../../services/ApiRequest/ApiRequest";
+import { Account } from "../../types";
+declare class Accounts implements AccountsInterface {
+    api: ApiRequest;
+    endpoint: string;
+    constructor(apiService: ApiRequest);
+    getAccount(accountId: string): Promise<Account>;
+}
+export default Accounts;

package/dist/endpoints/Accounts/Accounts.js

@@ -0,0 +1,26 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const HttpMethod_1 = require("../../services/ApiRequest/HttpMethod");
+const util_1 = require("../../util");
+class Accounts {
+    constructor(apiService) {
+        this.api = apiService;
+        this.endpoint = "/accounts";
+    }
+    getAccount(accountId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, util_1.validateString)("accountId", accountId);
+            return yield this.api.request(HttpMethod_1.HttpMethod.GET, `${this.endpoint}/${accountId}`);
+        });
+    }
+}
+exports.default = Accounts;

package/dist/endpoints/Accounts/AccountsInterface.d.ts

@@ -0,0 +1,4 @@
+import { Account } from "../../types";
+export interface AccountsInterface {
+    getAccount(accountId: string): Promise<Account>;
+}

package/dist/endpoints/Accounts/AccountsInterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/endpoints/ApiKeys/ApiKeys.d.ts

@@ -0,0 +1,13 @@
+import ApiRequest from "../../services/ApiRequest/ApiRequest";
+import { ApiKey, ApiKeyInput, UpdateApiKeyInput } from "../../types";
+import { ApiKeysInterface } from "./ApiKeysInterface";
+declare class ApiKeys implements ApiKeysInterface {
+    api: ApiRequest;
+    constructor(apiService: ApiRequest);
+    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 default ApiKeys;

package/dist/endpoints/ApiKeys/ApiKeys.js

@@ -0,0 +1,59 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const HttpMethod_1 = require("../../services/ApiRequest/HttpMethod");
+const lodash_omit_1 = __importDefault(require("lodash.omit"));
+const util_1 = require("../../util");
+class ApiKeys {
+    constructor(apiService) {
+        this.api = apiService;
+    }
+    authenticateKey(apikey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, util_1.validateString)("apikey", apikey);
+            return yield this.api.request(HttpMethod_1.HttpMethod.GET, `/api-keys/${apikey}`);
+        });
+    }
+    getKeys(projectId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, util_1.validateString)("projectId", projectId);
+            return yield this.api.request(HttpMethod_1.HttpMethod.GET, `/api-keys/?projectId=${projectId}`);
+        });
+    }
+    createKey(apiKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // validate string properties only
+            for (const [key, value] of Object.entries((0, lodash_omit_1.default)(apiKey, ["customMetaData", "rateLimitConfigs"]))) {
+                (0, util_1.validateString)(key, value);
+            }
+            return yield this.api.request(HttpMethod_1.HttpMethod.POST, "/api-keys", apiKey);
+        });
+    }
+    updateKey(apiKey, updateTo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, util_1.validateString)("apiKey", apiKey);
+            for (const [key, value] of Object.entries((0, lodash_omit_1.default)(updateTo, "customMetaData"))) {
+                (0, util_1.validateString)(key, value);
+            }
+            return yield this.api.request(HttpMethod_1.HttpMethod.PATCH, `/api-keys/${apiKey}`, updateTo);
+        });
+    }
+    deleteKey(apiKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, util_1.validateString)("apiKey", apiKey);
+            return yield this.api.request(HttpMethod_1.HttpMethod.DELETE, `/api-keys/${apiKey}`);
+        });
+    }
+}
+exports.default = ApiKeys;

package/dist/endpoints/ApiKeys/ApiKeysInterface.d.ts

@@ -0,0 +1,8 @@
+import { ApiKey, ApiKeyInput, UpdateApiKeyInput } from "../../types";
+export 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>;
+}

package/dist/endpoints/ApiKeys/ApiKeysInterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/endpoints/Projects/Projects.d.ts

@@ -0,0 +1,14 @@
+import ApiRequest from "../../services/ApiRequest/ApiRequest";
+import { Project, UpdateProjectInput } from "../../types";
+import { ProjectsInterface } from "./ProjectsInterface";
+declare class Projects implements ProjectsInterface {
+    api: ApiRequest;
+    endpoint: string;
+    constructor(apiService: ApiRequest);
+    getProjects(accountId: string): Promise<Project[]>;
+    getProject(projectId: string): Promise<Project>;
+    deleteProject(projectId: string): Promise<boolean>;
+    createProject(name: string, accountId: string): Promise<Project>;
+    updateProject(projectId: string, updateTo: UpdateProjectInput): Promise<Project>;
+}
+export default Projects;

package/dist/endpoints/Projects/Projects.js

@@ -0,0 +1,54 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const HttpMethod_1 = require("../../services/ApiRequest/HttpMethod");
+const util_1 = require("../../util");
+class Projects {
+    constructor(apiService) {
+        this.api = apiService;
+        this.endpoint = "/projects";
+    }
+    getProjects(accountId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, util_1.validateString)("accountId", accountId);
+            return yield this.api.request(HttpMethod_1.HttpMethod.GET, `${this.endpoint}?accountId=${accountId}`);
+        });
+    }
+    getProject(projectId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, util_1.validateString)("projectId", projectId);
+            return yield this.api.request(HttpMethod_1.HttpMethod.GET, `${this.endpoint}/${projectId}`);
+        });
+    }
+    deleteProject(projectId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, util_1.validateString)("projectId", projectId);
+            return yield this.api.request(HttpMethod_1.HttpMethod.DELETE, `${this.endpoint}/${projectId}`);
+        });
+    }
+    createProject(name, accountId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, util_1.validateString)("name", name);
+            (0, util_1.validateString)("accountId", accountId);
+            return yield this.api.request(HttpMethod_1.HttpMethod.POST, this.endpoint, {
+                name,
+                accountId,
+            });
+        });
+    }
+    updateProject(projectId, updateTo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, util_1.validateString)("projectId", projectId);
+            return this.api.request(HttpMethod_1.HttpMethod.PATCH, `${this.endpoint}/${projectId}`, updateTo);
+        });
+    }
+}
+exports.default = Projects;

package/dist/endpoints/Projects/ProjectsInterface.d.ts

@@ -0,0 +1,8 @@
+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/dist/endpoints/Projects/ProjectsInterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+import ApiRequest from "./services/ApiRequest/ApiRequest";
+import ApiKeys from "./endpoints/ApiKeys/ApiKeys";
+import Projects from "./endpoints/Projects/Projects";
+import Accounts from "./endpoints/Accounts/Accounts";
+declare type Options = {
+    host?: string;
+    timeout?: string | number;
+    cacheTTL?: number;
+    enable?: boolean;
+    retryCount?: number;
+};
+declare class TheAuthAPI {
+    queue: [];
+    accessKey: string;
+    host: string;
+    timeout: number | string | undefined;
+    cacheTTL: number;
+    api: ApiRequest;
+    apiKeys: ApiKeys;
+    projects: Projects;
+    accounts: Accounts;
+    /**
+     * 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);
+    authenticateAPIKey(key: string, callback?: (err: any, data: any) => any): Promise<unknown>;
+}
+export default TheAuthAPI;

package/dist/index.js

@@ -0,0 +1,89 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const remove_trailing_slash_1 = __importDefault(require("remove-trailing-slash"));
+const ApiRequest_1 = __importDefault(require("./services/ApiRequest/ApiRequest"));
+const util_1 = require("./util");
+const ApiKeys_1 = __importDefault(require("./endpoints/ApiKeys/ApiKeys"));
+const HttpMethod_1 = require("./services/ApiRequest/HttpMethod");
+const Projects_1 = __importDefault(require("./endpoints/Projects/Projects"));
+const Accounts_1 = __importDefault(require("./endpoints/Accounts/Accounts"));
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+const noop = () => { };
+class TheAuthAPI {
+    /**
+     * 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, options) {
+        var _a;
+        (0, assert_1.default)(accessKey, "You must pass your project's write key.");
+        this.queue = [];
+        this.accessKey = accessKey;
+        this.host = (0, remove_trailing_slash_1.default)((options === null || options === void 0 ? void 0 : options.host) || "https://api.theauthapi.com");
+        this.timeout = options === null || options === void 0 ? void 0 : options.timeout;
+        this.cacheTTL = (_a = options === null || options === void 0 ? void 0 : options.cacheTTL) !== null && _a !== void 0 ? _a : 60;
+        this.api = new ApiRequest_1.default({
+            accessKey: this.accessKey,
+            host: this.host,
+        });
+        this.apiKeys = new ApiKeys_1.default(this.api);
+        this.projects = new Projects_1.default(this.api);
+        this.accounts = new Accounts_1.default(this.api);
+        Object.defineProperty(this, "enable", {
+            configurable: false,
+            writable: false,
+            enumerable: true,
+            value: typeof (options === null || options === void 0 ? void 0 : options.enable) === "boolean" ? options.enable : true,
+        });
+    }
+    /*
+      @deprecated
+     */
+    authenticateAPIKey(key, callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, util_1.validateString)("key", key);
+            const cb = callback || noop;
+            const done = (err) => {
+                cb(err, data);
+            };
+            const data = {
+                credentials: { api_key: key },
+                timestamp: new Date().getTime(),
+                sentAt: new Date().getTime(),
+            };
+            try {
+                const key = yield this.api.request(HttpMethod_1.HttpMethod.POST, "/auth/authenticate", data);
+                done(key);
+                return key;
+            }
+            catch (err) {
+                if (err.response) {
+                    const error = new Error(err.response.statusText);
+                    return done(error);
+                }
+                done(err);
+            }
+        });
+    }
+}
+exports.default = TheAuthAPI;

package/dist/libraryMeta.d.ts

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

package/dist/libraryMeta.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.version = void 0;
+exports.version = "1.0.6";

package/dist/services/ApiRequest/ApiCall.d.ts

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

package/dist/services/ApiRequest/ApiCall.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/services/ApiRequest/ApiRequest.d.ts

@@ -0,0 +1,26 @@
+import { HttpMethod } from "./HttpMethod";
+import ApiCall from "./ApiCall";
+declare type Config = {
+    host: string;
+    accessKey: string;
+    headers?: object;
+    retryCount?: number;
+    timeout?: number | string;
+};
+declare class ApiRequest implements ApiCall {
+    host: string;
+    headers: object;
+    accessKey: string;
+    timeout: number;
+    retryCount: number;
+    constructor(config: Config);
+    _init(): void;
+    request<T>(method: HttpMethod, endpoint: string, payload?: any): Promise<T>;
+    _generateDefaultHeaders(): {
+        "user-agent": string;
+        "x-api-key": string;
+        "api-key": string;
+    };
+    _isErrorRetryable(error: any): boolean;
+}
+export default ApiRequest;

package/dist/services/ApiRequest/ApiRequest.js

@@ -0,0 +1,116 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const libraryMeta_1 = require("../../libraryMeta");
+const ApiRequestError_1 = __importDefault(require("./ApiRequestError"));
+const axios_retry_1 = __importDefault(require("axios-retry"));
+const ms_1 = __importDefault(require("ms"));
+class ApiRequest {
+    constructor(config) {
+        const { host, accessKey, headers, retryCount, timeout } = config;
+        this.host = host;
+        this.accessKey = accessKey;
+        this.headers = this._generateDefaultHeaders();
+        this.timeout = timeout ? (typeof timeout === "string" ? (0, ms_1.default)(timeout) : timeout) : 0;
+        this.retryCount = retryCount !== null && retryCount !== void 0 ? retryCount : 3;
+        if (headers) {
+            this.headers = Object.assign(Object.assign({}, this.headers), { headers });
+        }
+        this._init();
+    }
+    _init() {
+        var _a;
+        const isoDateFormat = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d*)?(?:[-+]\d{2}:?\d{2}|Z)?$/;
+        function isIsoDateString(value) {
+            return value && typeof value === "string" && isoDateFormat.test(value);
+        }
+        function handleDates(body) {
+            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_1.default.interceptors.response.use((response) => {
+            handleDates(response.data);
+            return response;
+        });
+        (0, axios_retry_1.default)(axios_1.default, {
+            retries: (_a = this.retryCount) !== null && _a !== void 0 ? _a : 3,
+            retryCondition: this._isErrorRetryable,
+            retryDelay: axios_retry_1.default.exponentialDelay,
+        });
+    }
+    request(method, endpoint, payload) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield axios_1.default.request({
+                    baseURL: this.host,
+                    method: method,
+                    url: endpoint,
+                    data: payload,
+                    headers: this.headers,
+                });
+                return response.data;
+            }
+            catch (error) {
+                if (axios_1.default.isAxiosError(error)) {
+                    if (error.response) {
+                        throw new ApiRequestError_1.default(error.response.status, (_a = error.response.data.message) !== null && _a !== void 0 ? _a : error.response.statusText);
+                    }
+                    else if (error.request) {
+                        throw new Error(error.request);
+                    }
+                }
+                throw error;
+            }
+        });
+    }
+    _generateDefaultHeaders() {
+        return {
+            "user-agent": `theauthapi-client-node/${libraryMeta_1.version}`,
+            "x-api-key": this.accessKey,
+            "api-key": this.accessKey,
+        };
+    }
+    _isErrorRetryable(error) {
+        // Retry Network Errors.
+        if (axios_retry_1.default.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;
+    }
+}
+exports.default = ApiRequest;

package/dist/services/ApiRequest/ApiRequestError.d.ts

@@ -0,0 +1,4 @@
+declare class ApiRequestError extends Error {
+    constructor(statusCode: number, message: string);
+}
+export default ApiRequestError;

package/dist/services/ApiRequest/ApiRequestError.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ApiRequestError extends Error {
+    constructor(statusCode, message) {
+        super(`(${statusCode}): ${message}`);
+    }
+}
+exports.default = ApiRequestError;

package/dist/services/ApiRequest/HttpMethod.d.ts

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

package/dist/services/ApiRequest/HttpMethod.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpMethod = void 0;
+var HttpMethod;
+(function (HttpMethod) {
+    HttpMethod["GET"] = "GET";
+    HttpMethod["POST"] = "POST";
+    HttpMethod["DELETE"] = "DELETE";
+    HttpMethod["PATCH"] = "PATCH";
+    HttpMethod["PUT"] = "PUT";
+})(HttpMethod = exports.HttpMethod || (exports.HttpMethod = {}));

package/dist/types/index.d.ts

@@ -0,0 +1,56 @@
+export declare type ApiKey = {
+    key: string;
+    name: string;
+    customMetaData: string;
+    customAccountId: string;
+    env: string;
+    createdAt: Date;
+    updatedAt: Date;
+};
+export declare type RateLimitConfiguration = {
+    rateLimitedEntity?: string;
+    ratelimitedEnitityId?: any;
+    rateLimit: number;
+    rateLimitTtl: number;
+};
+export declare type ApiKeyInput = {
+    name: string;
+    projectId: string;
+    key?: string;
+    customMetaData?: object;
+    customAccountId?: string;
+    rateLimitConfigs?: RateLimitConfiguration;
+    customUserId?: string;
+};
+export declare type UpdateApiKeyInput = {
+    name: string;
+    customMetaData?: object;
+    customAccountId?: string;
+};
+export declare enum AuthedEntityType {
+    USER = "USER",
+    ACCESS_KEY = "ACCESS_KEY"
+}
+export declare type AuthBaseEntity = {
+    isActive: boolean;
+    createdBy: string;
+    createdByType?: AuthedEntityType;
+    createdIn: string;
+    lastChangedBy: string;
+    lastChangedByType?: AuthedEntityType;
+    updatedAt: Date;
+    createdAt: Date;
+};
+export declare type Project = AuthBaseEntity & {
+    id: string;
+    name: string;
+    accountId: string;
+    env: string;
+};
+export declare type UpdateProjectInput = {
+    name: string;
+};
+export declare type Account = AuthBaseEntity & {
+    id: string;
+    name: string;
+};

package/dist/types/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthedEntityType = void 0;
+var AuthedEntityType;
+(function (AuthedEntityType) {
+    AuthedEntityType["USER"] = "USER";
+    AuthedEntityType["ACCESS_KEY"] = "ACCESS_KEY";
+})(AuthedEntityType = exports.AuthedEntityType || (exports.AuthedEntityType = {}));

package/dist/util/index.d.ts

@@ -0,0 +1 @@
+export declare function validateString(variableName: string, value: string): void;

package/dist/util/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateString = void 0;
+const lodash_isstring_1 = __importDefault(require("lodash.isstring"));
+function validateString(variableName, value) {
+    if (!value || !(0, lodash_isstring_1.default)(value)) {
+        throw new Error(`${variableName} must be a string`);
+    }
+}
+exports.validateString = validateString;

package/package.json

@@ -1,18 +1,19 @@
 {
   "name": "theauthapi",
-  "version": "1.0.3",
+  "version": "1.0.6",
   "description": "Client library for TheAuthAPI.com",
-  "main": "index.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "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",
@@ -28,32 +29,31 @@
     "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",
-    "dotenv": "^10.0.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"
   }
 }

package/index.js

@@ -1,182 +0,0 @@
-'use strict'
-
-const assert = require('assert')
-const removeSlash = require('remove-trailing-slash')
-const axios = require('axios')
-const axiosRetry = require('axios-retry')
-const ms = require('ms')
-const version = require('./package.json').version
-const isString = require('lodash.isstring')
-const NodeCache = require('node-cache')
-
-const noop = () => {}
-
-// const axios = require('axios').default;
-
-class TheAuthAPI {
-  /**
-   * Initialize a new `Analytics` with your Segment project's `writeKey` and an
-   * optional dictionary of `options`.
-   *
-   * @param {String} writeKey
-   * @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 (writeKey, options) {
-    options = options || {}
-
-    assert(writeKey, 'You must pass your project\'s write key.')
-    this.queue = []
-    this.writeKey = writeKey
-    this.host = removeSlash(options.host || 'https://api.theauthapi.com')
-    this.timeout = options.timeout || false
-    this.cacheTTL = options.cacheTTL || 60
-
-    Object.defineProperty(this, 'enable', {
-      configurable: false,
-      writable: false,
-      enumerable: true,
-      value: typeof options.enable === 'boolean' ? options.enable : true
-    })
-
-    axiosRetry(axios, {
-      retries: options.retryCount || 3,
-      retryCondition: this._isErrorRetryable,
-      retryDelay: axiosRetry.exponentialDelay
-    })
-
-    this.cache = new NodeCache({
-      stdTTL: this.cacheTTL,
-      checkperiod: this.cacheTTL * 0.2,
-      useClones: false
-    })
-  }
-
-  _validate (key, type) {
-    try {
-      if (!key || !isString(key)) throw new Error('must pass a string')
-    } catch (e) {
-      throw e
-    }
-  }
-
-  /**
-   * Send a track `message`.
-   *
-   * @param {Object} message
-   * @param {Function} [callback] (optional)
-   * @return {TheAnalyticsAPI}
-   */
-
-  async authenticateAPIKey (key, callback) {
-    this._validate(key, 'api_key')
-
-    callback = callback || noop
-
-    const data = {
-      credentials: { api_key: key },
-      timestamp: new Date().getTime(),
-      sentAt: new Date().getTime()
-    }
-
-    const done = err => {
-      // callbacks.forEach(callback => callback(err))
-      callback(err, data)
-    }
-
-    const headers = {}
-
-    headers['user-agent'] = `theauthapi-client-node/${version}`
-    headers['x-api-key'] = headers['api_key'] = this.writeKey
-
-    const req = {
-      method: 'POST',
-      url: `${this.host}/auth/authenticate`,
-      /* auth: {
-        username: this.writeKey
-      }, */
-      data,
-      headers
-    }
-
-    if (this.timeout) {
-      req.timeout = typeof this.timeout === 'string' ? ms(this.timeout) : this.timeout
-    }
-
-    try {
-      const resp = await axios(req)
-      done(resp.data)
-      return resp.data
-    } catch (err) {
-      if (err.response) {
-        const error = new Error(err.response.statusText)
-        return done(error)
-      }
-
-      done(err)
-    }
-  }
-
-  _isErrorRetryable (error) {
-    // 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
-  }
-
-  getCache (key) {
-    const value = this.cache.get(key)
-    if (value) {
-      return Promise.resolve(value)
-    } else {
-
-    }
-  }
-
-  setCache (key, value, ttl = null) {
-    if (ttl) this.cache.set(key, value, ttl)
-    else this.cache.set(key, value)
-  }
-
-  delCache (keys) {
-    this.cache.del(keys)
-  }
-  delCacheStartWith (startStr = '') {
-    if (!startStr) {
-      return
-    }
-
-    const keys = this.cache.keys()
-    for (const key of keys) {
-      if (key.indexOf(startStr) === 0) {
-        this.del(key)
-      }
-    }
-  }
-  flushCache () {
-    this.cache.flushAll()
-  }
-}
-
-module.exports = TheAuthAPI

package/test.js

@@ -1,139 +0,0 @@
-const express = require('express')
-// const delay = require('delay')
-// const pify = require('pify')
-const auth = require('basic-auth').auth
-require('dotenv').config()
-const test = require('ava')
-const version = require('./package.json').version
-const TheAuthAPI = require('.')
-/* var sinon = require('sinon')
-var spy = sinon.spy
-var stub = sinon.stub
-
-const noop = () => {}
-
-const context = {
-  library: {
-    name: 'theanalyticsapi',
-    version
-  }
-}
-
-const metadata = { nodeVersion: process.versions.node }
-*/
-const THE_AUTH_API_KEY = process.env.THE_AUTH_API_KEY
-const TEST_USERS_API_KEY = process.env.TEST_USERS_API_KEY
-
-const port = 4063
-
-const createClient = options => {
-  options = Object.assign({
-    host: `http://localhost:${port}`
-  }, options)
-
-  const client = new TheAuthAPI('key', options)
-  return client
-}
-
-test.before.cb(t => {
-  express()
-    .post('/auth/authenticate', (req, res) => {
-      const batch = req.body
-
-      const { name: writeKey } = auth(req)
-      if (!writeKey) {
-        return res.status(400).json({
-          error: { message: 'missing write key' }
-        })
-      }
-
-      const ua = req.headers['user-agent']
-      if (ua !== `theauthapi-client-node/${version}`) {
-        return res.status(400).json({
-          error: { message: 'invalid user-agent' }
-        })
-      }
-
-      if (batch[0] === 'error') {
-        return res.status(400).json({
-          error: { message: 'error' }
-        })
-      }
-
-      if (batch[0] === 'timeout') {
-        return setTimeout(() => res.end(), 5000)
-      }
-
-      res.json({})
-    })
-    .listen(port, t.end)
-})
-
-test('expose a constructor', t => {
-  t.is(typeof TheAuthAPI, 'function')
-})
-/*
-test('require a write key', t => {
-  t.throws(() => new TheAuthAPI(), 'You must pass your project\'s write key.')
-})
-*/
-test('default options', t => {
-  const client = new TheAuthAPI('key')
-
-  t.is(client.writeKey, 'key')
-  t.is(client.host, 'https://api.theauthapi.com')
-})
-
-test('remove trailing slashes from `host`', t => {
-  const client = new TheAuthAPI('key', { host: 'http://google.com///' })
-
-  t.is(client.host, 'http://google.com')
-})
-
-test('overwrite defaults with options', t => {
-  const client = new TheAuthAPI('key', {
-    host: 'a'
-  })
-
-  t.is(client.host, 'a')
-})
-
-test('test real request', async t => {
-  const client = new TheAuthAPI(THE_AUTH_API_KEY)
-
-  t.is(client.writeKey, THE_AUTH_API_KEY)
-  t.is(client.host, 'https://api.theauthapi.com')
-  const response = await client.authenticateAPIKey(TEST_USERS_API_KEY)
-
-  t.is(response.authenticated, true)
-  t.is(response.customAccountId, '1234-npm')
-  t.is(response.customMetadata.env, 'dev')
-})
-
-test('test real request bad key', async t => {
-  const client = new TheAuthAPI('bad key')
-
-  t.is(client.writeKey, 'bad key')
-  t.is(client.host, 'https://api.theauthapi.com')
-  const response = await client.authenticateAPIKey(TEST_USERS_API_KEY)
-
-  t.is(response.authenticated, true)
-  t.is(response.customAccountId, '1234-npm')
-  t.is(response.customMetadata.env, 'dev')
-})
-test('isErrorRetryable', t => {
-  const client = createClient()
-
-  t.false(client._isErrorRetryable({}))
-
-  // ETIMEDOUT is retryable as per `is-retry-allowed` (used by axios-retry in `isNetworkError`).
-  t.true(client._isErrorRetryable({ code: 'ETIMEDOUT' }))
-
-  // ECONNABORTED is not retryable as per `is-retry-allowed` (used by axios-retry in `isNetworkError`).
-  t.false(client._isErrorRetryable({ code: 'ECONNABORTED' }))
-
-  t.true(client._isErrorRetryable({ response: { status: 500 } }))
-  t.true(client._isErrorRetryable({ response: { status: 429 } }))
-
-  t.false(client._isErrorRetryable({ response: { status: 200 } }))
-})