@zcatalyst/auth-admin 0.0.3

package/dist-cjs/index.js

@@ -0,0 +1,229 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ZCAuth_instances, _ZCAuth_appCollection, _ZCAuth_loadOptionsFromObj, _ZCAuth_loadOptionsFromEnvVar;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CatalystAppError = exports.TicketCredential = exports.RefreshTokenCredential = exports.Credential = exports.AccessTokenCredential = exports.CatalystApp = exports.ZCAuth = void 0;
+exports.addDefaultAppHeaders = addDefaultAppHeaders;
+const utils_1 = require("@zcatalyst/utils");
+Object.defineProperty(exports, "CatalystAppError", { enumerable: true, get: function () { return utils_1.CatalystAppError; } });
+const credential_1 = require("./credential");
+const { INIT_TYPE, PROJECT_HEADER, DEFAULT_ENV, DEFAULT_APP_NAME, CREDENTIAL_USER, CATALYST_ORIGIN, AUTH_HEADER, COOKIE_HEADER, CREDENTIAL_HEADER, PROJECT_KEY_NAME, ENVIRONMENT_KEY_NAME, ENVIRONMENT, X_ZOHO_CATALYST_ORG_ID } = utils_1.CONSTANTS;
+let appOptions = {};
+class ZCAuth {
+    constructor() {
+        _ZCAuth_instances.add(this);
+        this.config = {};
+        _ZCAuth_appCollection.set(this, {});
+    }
+    init(options, { type, appName, scope } = {
+        type: 'auto'
+    }) {
+        switch (type) {
+            case INIT_TYPE.advancedio:
+                if (!options || typeof options.headers !== 'object') {
+                    throw new utils_1.CatalystAppError('INVALID_APP_OPTIONS', 'the options passed to initialize method is not valid', options);
+                }
+                appOptions = __classPrivateFieldGet(this, _ZCAuth_instances, "m", _ZCAuth_loadOptionsFromObj).call(this, options['headers']);
+                appOptions.credential = new credential_1.CatalystCredential(options['headers'], scope);
+                break;
+            case INIT_TYPE.basicio:
+                if (!options || typeof options.catalystHeaders !== 'object') {
+                    throw new utils_1.CatalystAppError('INVALID_APP_OPTIONS', 'the options passed to initialize method is not valid', options);
+                }
+                appOptions = __classPrivateFieldGet(this, _ZCAuth_instances, "m", _ZCAuth_loadOptionsFromObj).call(this, options['catalystHeaders']);
+                appOptions.credential = new credential_1.CatalystCredential(options['catalystHeaders'], scope);
+                break;
+            case INIT_TYPE.custom:
+                if (!options || !options['credential']) {
+                    throw new utils_1.CatalystAppError('INVALID_APP_OPTIONS', 'the options passed to initialize method is not valid', options);
+                }
+                if (appName && (0, utils_1.isNonEmptyString)(appName) && appName in __classPrivateFieldGet(this, _ZCAuth_appCollection, "f")) {
+                    throw new utils_1.CatalystAppError('APP_ALREADY_EXISTS', `The app with name ${appName} already exists. Please use a different name.`, appName);
+                }
+                appOptions = options;
+                appOptions.credential = new credential_1.ApplicationCustomCredential(options['credential']);
+                break;
+            default:
+                if (options && typeof options.headers === 'object') {
+                    return this.init(options, { type: INIT_TYPE.advancedio, appName, scope });
+                }
+                if (options && typeof options.catalystHeaders === 'object') {
+                    return this.init(options, { type: INIT_TYPE.basicio, appName, scope });
+                }
+                if (options && options['credential']) {
+                    return this.init(options, { type: INIT_TYPE.custom, appName, scope });
+                }
+                throw new utils_1.CatalystAppError('APP_ERROR', 'Unable to find the type of initialisation. kindly specify one', options);
+        }
+        const catalystApp = new CatalystApp(appOptions);
+        if (appName !== undefined && (0, utils_1.isNonEmptyString)(appName)) {
+            __classPrivateFieldGet(this, _ZCAuth_appCollection, "f")[appName] = catalystApp;
+        }
+        else {
+            __classPrivateFieldGet(this, _ZCAuth_appCollection, "f")[DEFAULT_APP_NAME] = catalystApp;
+        }
+        return catalystApp;
+    }
+    getDefaultCredentials(appName) {
+        if (typeof appName === 'undefined') {
+            appName = DEFAULT_APP_NAME;
+        }
+        if (!(0, utils_1.isNonEmptyObject)(appOptions)) {
+            appOptions = __classPrivateFieldGet(this, _ZCAuth_instances, "m", _ZCAuth_loadOptionsFromEnvVar).call(this);
+            if (!(0, utils_1.isNonEmptyObject)(appOptions)) {
+                throw new utils_1.CatalystAppError('AUTH_ERROR', 'Unable to get the app credentials, please initialize the app before perform operations.', appOptions);
+            }
+        }
+        if (typeof appOptions.credential === 'undefined') {
+            appOptions.credential = new credential_1.ApplicationDefaultCredential();
+        }
+        const app = new CatalystApp(appOptions);
+        app.credential.switchUser(CREDENTIAL_USER.admin);
+        __classPrivateFieldGet(this, _ZCAuth_appCollection, "f")[appName] = app;
+        return app;
+    }
+    app(appName) {
+        if (typeof appName === 'undefined') {
+            appName = DEFAULT_APP_NAME;
+        }
+        if (!(0, utils_1.isNonEmptyString)(appName)) {
+            throw new utils_1.CatalystAppError('INVALID_APP_NAME', 'Invalid app name provided. App name must be a non-empty string.', appName);
+        }
+        else if (!(appName in __classPrivateFieldGet(this, _ZCAuth_appCollection, "f"))) {
+            let errorMessage = appName === DEFAULT_APP_NAME
+                ? 'The default project does not exist. '
+                : `project named "${appName}" does not exist. `;
+            errorMessage += 'Make sure you call init() before getting the desired app';
+            throw new utils_1.CatalystAppError('no_app', errorMessage, appName);
+        }
+        return __classPrivateFieldGet(this, _ZCAuth_appCollection, "f")[appName];
+    }
+}
+exports.ZCAuth = ZCAuth;
+_ZCAuth_appCollection = new WeakMap(), _ZCAuth_instances = new WeakSet(), _ZCAuth_loadOptionsFromObj = function _ZCAuth_loadOptionsFromObj(obj) {
+    const projectId = obj[PROJECT_HEADER.id];
+    const projectKey = obj[PROJECT_HEADER.key];
+    const environment = obj[PROJECT_HEADER.environment] || DEFAULT_ENV;
+    const projectDomain = obj[PROJECT_HEADER.domain] || CATALYST_ORIGIN;
+    const projectSecretKey = obj[PROJECT_HEADER.projectSecretKey];
+    const origin = obj['host'] && obj['host'].trim()
+        ? `http://${obj['host']}`
+        : `https://${projectDomain}`;
+    if (!projectId) {
+        throw new utils_1.CatalystAppError('PROJECT_ERROR', 'Invalid project details. Failed to parse an object.', obj);
+    }
+    return {
+        projectId,
+        projectKey,
+        environment,
+        projectDomain,
+        projectSecretKey,
+        origin
+    };
+}, _ZCAuth_loadOptionsFromEnvVar = function _ZCAuth_loadOptionsFromEnvVar() {
+    const projectId = process.env[PROJECT_HEADER.id];
+    const projectKey = process.env[PROJECT_HEADER.key];
+    const environment = process.env[PROJECT_HEADER.environment] || DEFAULT_ENV;
+    const projectDomain = process.env[PROJECT_HEADER.domain] || CATALYST_ORIGIN;
+    const projectSecretKey = process.env[PROJECT_HEADER.projectSecretKey];
+    if (!(0, utils_1.isNonEmptyString)(!projectId)) {
+        return {};
+    }
+    try {
+        return {
+            projectId,
+            projectKey,
+            environment,
+            projectDomain,
+            projectSecretKey
+        };
+    }
+    catch (err) {
+        throw new utils_1.CatalystAppError('INVALID_APP_OPTIONS', 'Failed to parse app options : ' + err, err);
+    }
+};
+class CatalystApp {
+    constructor(options) {
+        try {
+            (0, utils_1.isNonNullObject)(options, 'options', true);
+            (0, utils_1.ObjectHasProperties)(options, ['credential'], 'options', true);
+            (0, utils_1.isNonNullObject)(options.credential, 'options.credential', true);
+            (0, utils_1.isValidType)(options.credential.getToken, 'function', 'options.credential', true);
+            (0, utils_1.isNonEmptyStringOrNumber)(options.project_id || options.projectId, 'projectId', true);
+        }
+        catch (e) {
+            if (e instanceof utils_1.CatalystError) {
+                throw new utils_1.CatalystAppError(e.code, e.message, e);
+            }
+            throw e;
+        }
+        this.credential = options.credential;
+        this.config = {
+            projectId: (options.project_id || options.projectId),
+            projectKey: (options.project_key || options.projectKey),
+            projectDomain: (options.project_domain || options.projectDomain),
+            environment: options.environment || DEFAULT_ENV,
+            projectSecretKey: (options.project_secret_key || options.projectSecretKey),
+            origin: options.origin || CATALYST_ORIGIN
+        };
+    }
+    setOauthHeader(headers, token) {
+        headers[AUTH_HEADER] = 'Zoho-oauthtoken ' + token;
+    }
+    setTicketHeader(headers, token) {
+        headers[AUTH_HEADER] = 'Zoho-ticket ' + token;
+    }
+    async authenticateRequest(req) {
+        const headers = Object.assign({}, req.headers);
+        if (this.credential instanceof credential_1.AccessTokenCredential ||
+            this.credential instanceof credential_1.RefreshTokenCredential) {
+            const token = await this.credential.getToken();
+            this.setOauthHeader(headers, token.access_token);
+            req.headers = headers;
+            return;
+        }
+        if (this.credential instanceof credential_1.TicketCredential) {
+            const token = await this.credential.getToken();
+            this.setTicketHeader(headers, token.ticket);
+            req.headers = headers;
+            return;
+        }
+        if (this.credential instanceof credential_1.CatalystCredential ||
+            this.credential instanceof credential_1.ApplicationDefaultCredential) {
+            const token = (await this.credential.getToken());
+            if ((0, utils_1.isNonEmptyString)(token.access_token)) {
+                this.setOauthHeader(headers, token.access_token);
+            }
+            else if ((0, utils_1.isNonEmptyString)(token.ticket)) {
+                this.setTicketHeader(headers, token.ticket);
+            }
+            else if ((0, utils_1.isNonEmptyString)(token.cookie)) {
+                headers[COOKIE_HEADER] = token.cookie;
+                headers[CREDENTIAL_HEADER.zcsrf] = token.zcrf_header;
+            }
+            req.headers = headers;
+        }
+    }
+}
+exports.CatalystApp = CatalystApp;
+function addDefaultAppHeaders(headers, values) {
+    headers[PROJECT_KEY_NAME] = values?.projectKey;
+    headers[ENVIRONMENT_KEY_NAME] = values?.environment;
+    headers[ENVIRONMENT] = values?.environment;
+    if ((0, utils_1.isNonEmptyString)(process.env.X_ZOHO_CATALYST_ORG_ID)) {
+        headers[X_ZOHO_CATALYST_ORG_ID] = process.env.X_ZOHO_CATALYST_ORG_ID;
+    }
+    if ((0, utils_1.isNonEmptyString)(values?.projectSecretKey)) {
+        headers[PROJECT_HEADER.projectSecretKey] = values?.projectSecretKey;
+    }
+    return headers;
+}
+var credential_2 = require("./credential");
+Object.defineProperty(exports, "AccessTokenCredential", { enumerable: true, get: function () { return credential_2.AccessTokenCredential; } });
+Object.defineProperty(exports, "Credential", { enumerable: true, get: function () { return credential_2.Credential; } });
+Object.defineProperty(exports, "RefreshTokenCredential", { enumerable: true, get: function () { return credential_2.RefreshTokenCredential; } });
+Object.defineProperty(exports, "TicketCredential", { enumerable: true, get: function () { return credential_2.TicketCredential; } });

package/dist-es/credential.js

@@ -0,0 +1,348 @@
+import { CONSTANTS } from '@zcatalyst/utils';
+import { readFileSync } from 'fs';
+import http from 'http';
+import https from 'https';
+import { resolve } from 'path';
+import { stringify } from 'querystring';
+import { CatalystAuthError } from './errors';
+const { CREDENTIAL_SUFFIX, REQ_METHOD, CREDENTIAL_HEADER, CREDENTIAL_TYPE, CREDENTIAL_USER, CSRF_TOKEN_NAME, ACCOUNTS_ORIGIN } = CONSTANTS;
+export const globalValue = {};
+const CREDENTIAL_PATH = process.env.HOME
+    ? resolve(resolve(process.env.HOME, '.config'), CREDENTIAL_SUFFIX)
+    : resolve('.', CREDENTIAL_SUFFIX);
+function getAttr(from, key, alt) {
+    const tmp = from[key] || (alt ? from[alt] : undefined);
+    if (typeof tmp === 'undefined') {
+        throw new CatalystAuthError('INVALID_CREDENTIAL', `Unable to get ${alt} from credential Object provided`, from);
+    }
+    return tmp;
+}
+function fromPath(filePath) {
+    let jsonString;
+    try {
+        jsonString = readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    try {
+        return JSON.parse(jsonString);
+    }
+    catch (err) {
+        throw new CatalystAuthError('INVALID_CREDENTIAL', 'Failed to parse token file: ' + err, err);
+    }
+}
+function fromEnv() {
+    const clientId = process.env['CLIENT_ID'];
+    const clientSecret = process.env['CLIENT_SECRET'];
+    const refreshToken = process.env['REFRESH_TOKEN'];
+    if (clientId && clientSecret && refreshToken) {
+        return {
+            client_id: clientId,
+            client_secret: clientSecret,
+            refresh_token: refreshToken
+        };
+    }
+    else {
+        throw new CatalystAuthError('INVALID_CREDENTIAL', `Failed to get the credential string from env variables`);
+    }
+}
+function _appendQueryData(url, data) {
+    if (data && Object.keys(data).length > 0) {
+        url += url.includes('?') ? '&' : '?';
+        url += stringify(data);
+    }
+    return url;
+}
+function isHttps(url) {
+    if (url === undefined) {
+        return false;
+    }
+    const parsedUrl = url instanceof URL ? url : new URL(url);
+    return parsedUrl.protocol !== 'http:';
+}
+async function _request(config) {
+    config.url = _appendQueryData(String(config.origin) + String(config.path), config.qs);
+    const parsedUrl = new URL(config.url);
+    if (parsedUrl.hostname === null) {
+        throw new CatalystAuthError('unparsable_config', 'Hostname cannot be null', config.path);
+    }
+    const isHttpsProtocol = isHttps(parsedUrl);
+    parsedUrl.searchParams?.sort();
+    const options = {
+        hostname: parsedUrl.hostname,
+        port: parsedUrl.port,
+        path: parsedUrl.pathname + parsedUrl.search,
+        method: config.method,
+        headers: {
+            'Content-Type': 'application/json',
+            ...(config.headers || {})
+        }
+    };
+    const transport = isHttpsProtocol ? https : http;
+    return new Promise((resolve, reject) => {
+        const req = transport.request(options, (res) => {
+            const chunks = [];
+            res.on('data', (chunk) => {
+                chunks.push(chunk);
+            });
+            res.on('end', () => {
+                const body = Buffer.concat(chunks).toString();
+                const response = {
+                    headers: res.headers,
+                    request: req,
+                    stream: res,
+                    statusCode: res.statusCode,
+                    config,
+                    body
+                };
+                resolve(response);
+            });
+        });
+        req.on('error', (err) => {
+            reject(err);
+        });
+        req.write(JSON.stringify({ your: 'data' }));
+        req.end();
+    });
+}
+async function requestAccessToken(request) {
+    const options = {
+        method: request.method,
+        origin: request.origin,
+        qs: request.qs,
+        path: request.path
+    };
+    const resp = await _request(options);
+    const json = JSON.parse(resp.body);
+    if (json.error) {
+        const errorMessage = 'Error fetching access token: ' + json.error;
+        return Promise.reject(errorMessage);
+    }
+    else if (!json.access_token || !json.expires_in) {
+        return Promise.reject(`Unexpected response while fetching access token: ${JSON.stringify(json)}`);
+    }
+    else {
+        return json;
+    }
+}
+export class Credential {
+    getCurrentUser() {
+        return CREDENTIAL_USER.admin;
+    }
+    switchUser(_givenUser) {
+        return null;
+    }
+    getCurrentUserType() {
+        return CREDENTIAL_USER.admin;
+    }
+}
+export class RefreshTokenCredential extends Credential {
+    constructor(refreshObj) {
+        super();
+        this.clientId = getAttr(refreshObj, 'clientId', 'client_id');
+        this.clientSecret = getAttr(refreshObj, 'clientSecret', 'client_secret');
+        this.refreshToken = getAttr(refreshObj, 'refreshToken', 'refresh_token');
+        this.cachedToken = null;
+    }
+    async getToken() {
+        if (this.cachedToken === null || this.cachedToken['expires_in'] <= Date.now()) {
+            const token = await requestAccessToken({
+                method: REQ_METHOD.post,
+                origin: ACCOUNTS_ORIGIN,
+                path: '/oauth/v2/token',
+                qs: {
+                    client_id: this.clientId,
+                    client_secret: this.clientSecret,
+                    refresh_token: this.refreshToken,
+                    grant_type: 'refresh_token'
+                }
+            });
+            this.cachedToken = token;
+            this.cachedToken.expires_in = Date.now() + token.expires_in * 1000;
+        }
+        return this.cachedToken;
+    }
+}
+export class AccessTokenCredential extends Credential {
+    constructor(accessObj) {
+        super();
+        this.accessToken = getAttr(accessObj, 'accessToken', 'access_token');
+    }
+    async getToken() {
+        return Promise.resolve({
+            access_token: this.accessToken
+        });
+    }
+}
+export class TicketCredential extends Credential {
+    constructor(ticketObj) {
+        super();
+        this.ticket = getAttr(ticketObj, 'ticket', 'ticket');
+    }
+    async getToken() {
+        return Promise.resolve({ ticket: this.ticket });
+    }
+}
+export class CookieCredential extends Credential {
+    constructor(cookieObj) {
+        super();
+        this.cookie = getAttr(cookieObj, 'cookie', 'cookie');
+        this.cookieObj = {};
+    }
+    getAsObject() {
+        if (Object.keys(this.cookieObj).length > 0) {
+            return this.cookieObj;
+        }
+        this.cookie.split(';').forEach((cookie) => {
+            const parts = cookie.split('=');
+            this.cookieObj[parts.shift()?.trim()] = decodeURI(parts.join('='));
+        });
+        return this.cookieObj;
+    }
+    getZCSRFHeader() {
+        const cookieObj = this.getAsObject();
+        return 'zd_csrparam=' + cookieObj[CSRF_TOKEN_NAME];
+    }
+    async getToken() {
+        return Promise.resolve({ cookie: this.cookie, zcrf_header: this.getZCSRFHeader() });
+    }
+}
+export class CatalystCredential extends Credential {
+    constructor(credObj, scope) {
+        super();
+        this.adminCredType = getAttr(credObj, 'adminType', CREDENTIAL_HEADER.admin_cred_type);
+        this.adminToken = getAttr(credObj, 'adminToken', CREDENTIAL_HEADER.admin_token);
+        this.userCredType = credObj[CREDENTIAL_HEADER.user_cred_type];
+        this.userToken = credObj[CREDENTIAL_HEADER.user_token];
+        this.cookieStr = credObj[CREDENTIAL_HEADER.cookie];
+        this.userType =
+            credObj[CREDENTIAL_HEADER.user] === CREDENTIAL_USER.admin
+                ? CREDENTIAL_USER.admin
+                : CREDENTIAL_USER.user;
+        this.scope = scope || this.userType;
+        if (this.scope === CREDENTIAL_USER.user) {
+            if (this.userType === CREDENTIAL_USER.admin) {
+                throw new CatalystAuthError('AUTH_ERROR', 'User not authenticated. Please login to proceed with user scope', credObj);
+            }
+            if (this.userToken === undefined && this.cookieStr === undefined) {
+                throw new CatalystAuthError('INVALID_CREDENTIAL', 'missing user credentials', credObj);
+            }
+        }
+        switch (this.adminCredType) {
+            case CREDENTIAL_TYPE.ticket:
+                this.adminCred = new TicketCredential({ ticket: this.adminToken });
+                break;
+            case CREDENTIAL_TYPE.token:
+                this.adminCred = new AccessTokenCredential({ access_token: this.adminToken });
+                break;
+            default:
+                throw new CatalystAuthError('INVALID_CREDENTIAL', 'admin credential type is unknown', credObj);
+        }
+        switch (this.userCredType) {
+            case CREDENTIAL_TYPE.ticket:
+                this.userCred = new TicketCredential({ ticket: this.userToken });
+                break;
+            case CREDENTIAL_TYPE.token:
+                this.userCred = new AccessTokenCredential({
+                    access_token: this.userToken
+                });
+                break;
+            default:
+                if (this.cookieStr !== undefined) {
+                    this.userCred = new CookieCredential({
+                        cookie: this.cookieStr
+                    });
+                }
+        }
+    }
+    async getToken() {
+        switch (this.scope) {
+            case CREDENTIAL_USER.admin:
+                return this.adminCred.getToken();
+            case CREDENTIAL_USER.user:
+                if (this.userCred === undefined) {
+                    throw new CatalystAuthError('INVALID_CREDENTIAL', 'User Credential is not initialised', this.scope);
+                }
+                return this.userCred.getToken();
+            default:
+                throw new CatalystAuthError('INVALID_CREDENTIAL', 'user provided is not recognized', this.scope);
+        }
+    }
+    getScope() {
+        return this.scope;
+    }
+    getCurrentUser() {
+        return this.scope;
+    }
+    getCurrentUserType() {
+        if (this.scope === CREDENTIAL_USER.user) {
+            return this.userType;
+        }
+        return this.scope;
+    }
+    switchUser(givenUser) {
+        if (givenUser === undefined) {
+            switch (this.scope) {
+                case CREDENTIAL_USER.admin:
+                    givenUser = CREDENTIAL_USER.user;
+                    break;
+                case CREDENTIAL_USER.user:
+                    givenUser = CREDENTIAL_USER.admin;
+                    break;
+            }
+        }
+        this.scope = givenUser;
+        return this.scope;
+    }
+}
+export class ApplicationDefaultCredential extends Credential {
+    constructor() {
+        super();
+        let token = fromPath(CREDENTIAL_PATH);
+        if (token === undefined || token === null) {
+            token = fromEnv();
+        }
+        if (token === undefined || token === null) {
+            throw new CatalystAuthError('INVALID_CREDENTIAL', 'Unable to get token object from path or env', token);
+        }
+        if ('refresh_token' in token) {
+            this.credential = new RefreshTokenCredential(token);
+        }
+        else if ('access_token' in token) {
+            this.credential = new AccessTokenCredential(token);
+        }
+        else if ('ticket' in token) {
+            this.credential = new TicketCredential(token);
+        }
+        else {
+            throw new CatalystAuthError('INVALID_CREDENTIAL', 'The given token object does not contain proper credentials', token);
+        }
+    }
+    async getToken() {
+        return this.credential.getToken();
+    }
+}
+export class ApplicationCustomCredential extends Credential {
+    constructor(credObj) {
+        super();
+        if (credObj === undefined || credObj === null) {
+            throw new CatalystAuthError('INVALID_CREDENTIAL', 'Unable to get token object from path or env', credObj);
+        }
+        if ('refresh_token' in credObj) {
+            this.credential = new RefreshTokenCredential(credObj);
+        }
+        else if ('access_token' in credObj) {
+            this.credential = new AccessTokenCredential(credObj);
+        }
+        else if ('ticket' in credObj) {
+            this.credential = new TicketCredential(credObj);
+        }
+        else {
+            throw new CatalystAuthError('INVALID_CREDENTIAL', 'The given token object does not contain proper credentials', credObj);
+        }
+    }
+    async getToken() {
+        return this.credential.getToken();
+    }
+}

package/dist-es/errors.js

@@ -0,0 +1,6 @@
+import { PrefixedCatalystError } from '@zcatalyst/utils';
+export class CatalystAuthError extends PrefixedCatalystError {
+    constructor(code, message, value) {
+        super('app', code, message, value);
+    }
+}