@useparagon/connect 0.0.16-canary.2

package/dist/src/utils/http.d.ts

@@ -0,0 +1,57 @@
+/**
+ * check if url is valid or not
+ * @param url
+ * @returns
+ */
+export declare const isValidUrl: (url: string) => boolean;
+/**
+ * it will add https protocol if protocol is not added in utl
+ * @param url
+ * @returns
+ */
+export declare function sanitizeUrl(url: string): string;
+export declare function getServiceUrl(service: string, domain: string, envPrefix?: string): string;
+/**
+ * Validation error description.
+ * @see https://github.com/typestack/class-validator
+ *
+ * class-validator@0.13.0
+ *
+ * @publicApi
+ */
+export interface ValidationError {
+    /**
+     * Constraints that failed validation with error messages.
+     */
+    constraints?: {
+        [type: string]: string;
+    };
+    /**
+     * Contains all nested validation errors of the property.
+     */
+    children?: ValidationError[];
+}
+export type MessageWithErrorBody = {
+    message: string;
+    response: Record<string, unknown>;
+};
+/**
+ * extract error message from response object
+ * @param response
+ * @returns
+ */
+export declare function getErrorMessage(response: Response): Promise<string>;
+export declare function getErrorMessage(response: Response, isProxyRequestFailure: true): Promise<MessageWithErrorBody>;
+export declare function getErrorMessage(response: Response, isProxyRequestFailure: false): Promise<string>;
+export declare class ProxyRequestError extends Error {
+    response: Record<string, unknown>;
+    constructor(message: string, response: any);
+}
+export declare const isIntegrationError: (error: unknown) => boolean;
+/**
+ * Parses an error message and determines if it represents an integration error.
+ *
+ * @param {string | Error} err - The error message or Error object to parse.
+ * @returns {boolean} - True if the error represents an integration error, false otherwise.
+ */
+export declare function errorMessageParser(err: string | Error): boolean;

package/dist/src/utils/throttle.d.ts

@@ -0,0 +1,118 @@
+/**
+ * whether to debounce or throttle cached items
+ * defaults to `Debounce` behavior
+ */
+export declare enum CacheMode {
+    Debounce = "debounce",
+    Throttle = "throttle"
+}
+/**
+ * configuration parameters for a CacheThrottle instance
+ */
+export type CacheThrottleConfig<T = any> = Partial<{
+    /**
+     * when enabled, this clears pending `del` calls from the queue when `get`, `set`, or `getOrSet` is called
+     * this can be used to prevent queued delete calls from deleting recently retrieved stateful values, like db connections
+     */
+    clearPendingDeletes: boolean;
+    /**
+     * whether to operate in Throttle or Debounce mode
+     */
+    mode: CacheMode;
+    /**
+     * an optional callback for handling items when they get deregistered from the cache
+     */
+    onDeregister: (value: T) => Promise<void> | void;
+    /**
+     * an optional callback for serializing keys
+     * in the case that keys are particularly long, this can be used to shorten them
+     */
+    serializeKey: (key: string) => string;
+    /**
+     * how long items should remain in the cache
+     * the ttl is reset every time a key is accessed
+     */
+    ttl: number;
+}>;
+/**
+ * A helper class for caching items in memory and throttling / debouncing function calls
+ * methods for getters, setters, and executors are queued to prevent race conditions between calls.
+ * It provides helper methods for handling deregistering of items.
+ * Useful for caching database connections or rate-limiting outgoing Sentry calls.
+ */
+export declare class CacheThrottle<T = any> {
+    #private;
+    constructor(config?: CacheThrottleConfig<T>);
+    /**
+     * attempts to retrieve a key from the cache
+     *
+     * @param {string} key
+     * @param {boolean} [asap] asap = as soon as possible. should this be queued or execute immediately
+     * @returns {(Promise<T | undefined>)}
+     * @memberof CacheThrottle
+     */
+    get(key: string, asap?: boolean): Promise<T | undefined>;
+    /**
+     * stores an item in the cache
+     *
+     * @param {string} key
+     * @param {T} value
+     * @param {number} [ttl=this.]
+     * @param {*} config
+     * @param {*} ttl
+     * @param {CacheMode} [mode]
+     * @param {boolean} [asap] asap = as soon as possible. should this be queued or execute immediately
+     * @returns {Promise<T>}
+     * @memberof CacheThrottle
+     */
+    set(key: string, value: T, ttl?: number, mode?: CacheMode, asap?: boolean): Promise<T>;
+    /**
+     * attempts to retrieve a value from the cache
+     * if it's not available, it sets the value using the provided generator method
+     */
+    getOrSet(key: string, generator: () => T | Promise<T>, ttl?: number, mode?: CacheMode, asap?: boolean): Promise<T>;
+    /**
+     * deletes an item from the cache
+     *
+     * @param {string} key
+     * @param {boolean} [isKeySerialized=false]
+     * @param {boolean} [asap] asap = as soon as possible. should this be queued or execute immediately
+     * @returns {(Promise<T | undefined>)}
+     * @memberof CacheThrottle
+     */
+    del(key: string, isKeySerialized?: boolean, asap?: boolean): Promise<T | undefined>;
+    /**
+     * returns the keys stored in the cache
+     */
+    keys(): string[];
+    /**
+     * executes a method. the `key` is used as a unique identifier for rate-limiting calls
+     */
+    do(key: string, method: () => T | Promise<T>, ttl?: number, mode?: CacheMode): Promise<T>;
+    /**
+     * removes all the items from the cache, clears timeouts, and calls deregister methods
+     */
+    close(): Promise<void>;
+    /**
+     * refreshes a set interval for clearing an item from the cache
+     * if an existing interval exists, it removes it
+     */
+    private refreshTimeout;
+    /**
+     * removes any pending delete calls on a key
+     * @param key
+     */
+    private clearPendingDeletesOnKey;
+    /**
+     * generates the key used for storing items in the cache
+     */
+    private serializeKey;
+    /**
+     * queues a method for processing
+     */
+    private enqueue;
+    /**
+     * calls the methods in the queue
+     */
+    private flush;
+}

package/package.json

@@ -0,0 +1,103 @@
+{
+  "name": "@useparagon/connect",
+  "version": "0.0.16-canary.2",
+  "description": "Embed integrations into your app with the Paragon SDK",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "exports": "./dist/src/index.js",
+  "scripts": {
+    "build:prod": "yarn typecheck && yarn clean && webpack --config webpack.config.js",
+    "build:watch": "yarn build --watch",
+    "build": "yarn typecheck && yarn clean && webpack --config webpack.config.js",
+    "ci:compile": "whiskers",
+    "clean:server": "rimraf ./dist/src",
+    "clean": "rimraf coverage dist",
+    "format:check": "prettier --ignore-path=./prettierignore --config=prettier.config.js --check .",
+    "format": "prettier --ignore-path=./.prettierignore --write .",
+    "lint:cmd": "eslint --no-error-on-unmatched-pattern -c ./.eslintrc.js --cache --cache-strategy content --cache-location ./eslintcache/ --quiet",
+    "lint:fix": "yarn -s lint --fix",
+    "lint:staged": "yarn -s lint:cmd --fix",
+    "lint": "NODE_OPTIONS=--max-old-space-size=4096 yarn -s lint:cmd \"src{/**/,/}*.{js,jsx,ts,tsx}\"",
+    "prebuild": "yarn -s clean",
+    "release:publish:experimental": "yarn publish --new-version=$npm_package_version --tag=experimental",
+    "release:publish:stable": "yarn publish --new-version=$npm_package_version --tag=latest",
+    "release:version:bump": "ts-node ./scripts/version-bump.ts",
+    "test": "NODE_OPTIONS=--max-old-space-size=4096 jest",
+    "typecheck": "tsc -p tsconfig.json"
+  },
+  "dependencies": {
+    "hash.js": "^1.1.7",
+    "jwt-decode": "^3.1.2",
+    "react": "^17.0.2",
+    "tslib": "2.3.1"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.12.3",
+    "@babel/preset-env": "^7.12.1",
+    "@babel/preset-react": "^7.12.5",
+    "@testing-library/jest-dom": "^5.14.1",
+    "@testing-library/react": "^12.1.0",
+    "@types/gapi": "^0.0.47",
+    "@types/google.picker": "^0.0.42",
+    "@types/jest": "^29.5.1",
+    "@types/node": "^18.13.0",
+    "@types/react": "^17.0.11",
+    "@types/react-dom": "^17.0.8",
+    "@typescript-eslint/eslint-plugin": "^5.21.0",
+    "@typescript-eslint/eslint-plugin-tslint": "^5.21.0",
+    "@typescript-eslint/parser": "^5.21.0",
+    "@useparagon/whiskers-cli": "^0.0.1-canary.15",
+    "babel-loader": "^8.2.1",
+    "concurrently": "^6.2.0",
+    "crypto-browserify": "^3.12.0",
+    "dotenv-webpack": "^7.0.3",
+    "eslint": "^8.14.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-jest": "^27.0.1",
+    "eslint-plugin-prettier": "^4.2.1",
+    "eslint-plugin-react": "^7.29.4",
+    "eslint-plugin-react-hooks": "^4.4.0",
+    "eslint-plugin-unicorn": "^41.0.0",
+    "glob": "^10.3.10",
+    "jest": "^27.0.6",
+    "jest-fetch-mock": "useparagon/jest-fetch-mock.git#3.0.4",
+    "jest-json": "^1.0.4",
+    "jest-json-reporter2": "^1.1.0",
+    "node-notifier": "^10.0.0",
+    "nyc": "^15.1.0",
+    "pkg": "^5.8.1",
+    "prettier": "^2.2.1",
+    "process": "^0.11.10",
+    "react-dom": "^17.0.2",
+    "rimraf": "^3.0.2",
+    "stream-browserify": "^3.0.0",
+    "stream-http": "^3.2.0",
+    "terser-webpack-plugin": "^5.3.7",
+    "ts-jest": "^27.0.5",
+    "ts-loader": "^6.2.1",
+    "ts-node": "^10.0.0",
+    "tsconfig-paths-webpack-plugin": "^3.2.0",
+    "tslint": "6.1.2",
+    "typescript": "^4.4.4",
+    "util": "^0.12.4",
+    "uuid": "^9.0.0",
+    "webpack": "^5.75.0",
+    "webpack-bundle-analyzer": "^4.3.0",
+    "webpack-cli": "^5.0.2"
+  },
+  "license": "MIT",
+  "pkg": {
+    "scripts": "./dist/**/*.js",
+    "assets": [
+      "./node_modules/**/*",
+      "./dist/src/**/*",
+      "./dist/**/*.json"
+    ]
+  },
+  "resolutions": {
+    "string-width": "^4.2.3",
+    "strip-ansi": "^6.0.1",
+    "wrap-ansi": "^6.2.0"
+  }
+}