@rvoh/psychic 0.24.1

package/dist/cjs/src/controller/index.js

@@ -0,0 +1,571 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.controllerSerializerIndex = exports.ControllerSerializerIndex = exports.PsychicParamsPrimitiveLiterals = void 0;
+const dream_1 = require("@rvoh/dream");
+const BadGateway_js_1 = require("../error/http/BadGateway.js");
+const BadRequest_js_1 = require("../error/http/BadRequest.js");
+const Conflict_js_1 = require("../error/http/Conflict.js");
+const ContentTooLarge_js_1 = require("../error/http/ContentTooLarge.js");
+const ExpectationFailed_js_1 = require("../error/http/ExpectationFailed.js");
+const FailedDependency_js_1 = require("../error/http/FailedDependency.js");
+const Forbidden_js_1 = require("../error/http/Forbidden.js");
+const GatewayTimeout_js_1 = require("../error/http/GatewayTimeout.js");
+const Gone_js_1 = require("../error/http/Gone.js");
+const ImATeapot_js_1 = require("../error/http/ImATeapot.js");
+const InsufficientStorage_js_1 = require("../error/http/InsufficientStorage.js");
+const InternalServerError_js_1 = require("../error/http/InternalServerError.js");
+const Locked_js_1 = require("../error/http/Locked.js");
+const MethodNotAllowed_js_1 = require("../error/http/MethodNotAllowed.js");
+const MisdirectedRequest_js_1 = require("../error/http/MisdirectedRequest.js");
+const NotAcceptable_js_1 = require("../error/http/NotAcceptable.js");
+const NotExtended_js_1 = require("../error/http/NotExtended.js");
+const NotFound_js_1 = require("../error/http/NotFound.js");
+const NotImplemented_js_1 = require("../error/http/NotImplemented.js");
+const PaymentRequired_js_1 = require("../error/http/PaymentRequired.js");
+const PreconditionFailed_js_1 = require("../error/http/PreconditionFailed.js");
+const PreconditionRequired_js_1 = require("../error/http/PreconditionRequired.js");
+const ProxyAuthenticationRequired_js_1 = require("../error/http/ProxyAuthenticationRequired.js");
+const RequestHeaderFieldsTooLarge_js_1 = require("../error/http/RequestHeaderFieldsTooLarge.js");
+const ServiceUnavailable_js_1 = require("../error/http/ServiceUnavailable.js");
+const status_codes_js_1 = require("../error/http/status-codes.js");
+const TooManyRequests_js_1 = require("../error/http/TooManyRequests.js");
+const Unauthorized_js_1 = require("../error/http/Unauthorized.js");
+const UnavailableForLegalReasons_js_1 = require("../error/http/UnavailableForLegalReasons.js");
+const UnprocessableContent_js_1 = require("../error/http/UnprocessableContent.js");
+const UnsupportedMediaType_js_1 = require("../error/http/UnsupportedMediaType.js");
+const params_js_1 = require("../server/params.js");
+const index_js_1 = require("../session/index.js");
+exports.PsychicParamsPrimitiveLiterals = [
+    'bigint',
+    'bigint[]',
+    'boolean',
+    'boolean[]',
+    'date',
+    'date[]',
+    'datetime',
+    'datetime[]',
+    'integer',
+    'integer[]',
+    'json',
+    'json[]',
+    'null',
+    'null[]',
+    'number',
+    'number[]',
+    'string',
+    'string[]',
+    'uuid',
+    'uuid[]',
+];
+class InvalidDotNotationPath extends Error {
+}
+class PsychicController {
+    /**
+     * @internal
+     *
+     * Used internally as a helpful distinguisher between controllers
+     * and non-controllers
+     */
+    static get isPsychicController() {
+        return true;
+    }
+    /**
+     * @internal
+     *
+     * Certain features (e.g. building OpenAPI specs from Attribute and RendersOne/Many decorators)
+     * need static access to things set up by decorators. Stage 3 Decorators change the context that is available
+     * at decoration time such that the class of a property being decorated is only avilable during instance instantiation. In order
+     * to only apply static values once, on boot, `globallyInitializingDecorators` is set to true on PsychicController,
+     * and all controllers are instantiated.
+     *
+     */
+    static globallyInitializingDecorators = false;
+    /**
+     * @internal
+     *
+     * Storage for controller action metadata, set when using the association decorators like:
+     *   @OpenAPI
+     */
+    static controllerActionMetadata = {};
+    /**
+     * @internal
+     *
+     * Used to store controller hooks, which are registered
+     * by using the `@BeforeAction` decorator on your controllers
+     */
+    static controllerHooks = [];
+    /**
+     * @internal
+     *
+     * Used to store openapi data, which is registered
+     * by using the `@Openapi` decorator on your controller methods
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static openapi;
+    /**
+     * Enables you to specify specific serializers to use
+     * when encountering specific models, i.e.
+     *
+     * ```ts
+     * class MyController extends AuthedController {
+     *   static {
+     *     this.serializes(User).with(UserCustomSerializer)
+     *   }
+     * }
+     * ````
+     */
+    static serializes(ModelClass) {
+        return {
+            with: (SerializerClass) => {
+                exports.controllerSerializerIndex.add(this, SerializerClass, ModelClass);
+                return this;
+            },
+        };
+    }
+    /**
+     * @internal
+     *
+     * Returns the global identifier for this particular controller.
+     * When you first initialize your application, the controllers
+     * you provide are organized into a map of key-value pairs,
+     * where the keys are global identifiers for each controller, and
+     * the values are the matching controllers. The key returned here
+     * enables a lookup of the controller from the PsychicApplication
+     * class.
+     */
+    static get globalName() {
+        if (!this._globalName)
+            throw new dream_1.GlobalNameNotSet(this);
+        return this._globalName;
+    }
+    static setGlobalName(globalName) {
+        this._globalName = globalName;
+    }
+    static _globalName;
+    /**
+     * @internal
+     *
+     * Used for displaying routes when running `yarn psy routes`
+     * cli command
+     */
+    static get disaplayName() {
+        return this.globalName.replace(/^controllers\//, '').replace(/Controller$/, '');
+    }
+    /**
+     * @internal
+     *
+     * Returns a controller-action string which is used to signify both
+     * the controller and the method to be called for a particular route.
+     * For the controller "Api/V1/UsersController" and the method "show",
+     * the controllerActionPath would return:
+     *
+     *   "Api/V1/Users#show"
+     */
+    static controllerActionPath(methodName) {
+        return `${this.globalName.replace(/^controllers\//, '').replace(/Controller$/, '')}#${methodName.toString()}`;
+    }
+    static get openapiNames() {
+        return ['default'];
+    }
+    static get openapiConfig() {
+        return {};
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    get psychicTypes() {
+        throw new Error('Must define psychicTypes getter in ApplicationController class within your application');
+    }
+    /**
+     * @internal
+     *
+     * Used internally as a helpful distinguisher between controllers
+     * and non-controllers
+     */
+    get isPsychicControllerInstance() {
+        return true;
+    }
+    req;
+    res;
+    session;
+    config;
+    action;
+    constructor(req, res, { config, action, }) {
+        this.req = req;
+        this.res = res;
+        this.config = config;
+        this.session = new index_js_1.default(req, res);
+        this.action = action;
+    }
+    get params() {
+        const params = {
+            ...this.req.params,
+            ...this.req.body,
+            ...this.req.query,
+        };
+        return params;
+    }
+    param(key) {
+        return this.params[key];
+    }
+    castParam(key, expectedType, opts) {
+        try {
+            return this._castParam(key.split('.'), this.params, expectedType, opts);
+        }
+        catch (error) {
+            if (error instanceof InvalidDotNotationPath)
+                throw new params_js_1.ParamValidationError(`Invalid dot notation in castParam: ${key}`);
+            throw error;
+        }
+    }
+    _castParam(keys, params, expectedType, opts) {
+        const key = keys.shift();
+        if (!keys.length)
+            return params_js_1.default.cast(params[key], expectedType, opts);
+        const nestedParams = params[key];
+        if (nestedParams === undefined) {
+            if (opts?.allowNull)
+                return null;
+            throw new InvalidDotNotationPath();
+        }
+        else if (Array.isArray(nestedParams)) {
+            throw new InvalidDotNotationPath();
+        }
+        else if (typeof nestedParams !== 'object') {
+            throw new InvalidDotNotationPath();
+        }
+        return this._castParam(keys, nestedParams, expectedType, opts);
+    }
+    paramsFor(dreamClass, opts) {
+        return params_js_1.default.for(opts?.key ? this.params[opts.key] || {} : this.params, dreamClass, opts);
+    }
+    getCookie(name) {
+        return (this.session.getCookie(name) ?? null);
+    }
+    setCookie(name, data, opts = {}) {
+        return this.session.setCookie(name, data, opts);
+    }
+    startSession(user) {
+        return this.setCookie(this.config.sessionCookieName, JSON.stringify({
+            id: user.primaryKeyValue,
+            modelKey: user.constructor.globalName,
+        }));
+    }
+    endSession() {
+        return this.session.clearCookie(this.config.sessionCookieName);
+    }
+    singleObjectJson(data, opts) {
+        if (!data)
+            return data;
+        const dreamApp = dream_1.DreamApplication.getOrFail();
+        const psychicControllerClass = this.constructor;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+        const lookup = exports.controllerSerializerIndex.lookupModel(this.constructor, data.constructor);
+        if (lookup?.length) {
+            const serializerClass = lookup?.[1];
+            if (typeof serializerClass === 'function' && serializerClass.isDreamSerializer) {
+                return new serializerClass(data).passthrough(this.defaultSerializerPassthrough).render();
+            }
+        }
+        else {
+            const serializerKey = 
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+            data.serializers?.[opts.serializerKey ||
+                psychicControllerClass['controllerActionMetadata'][this.action]?.['serializerKey'] ||
+                'default'];
+            if (serializerKey && Object.prototype.hasOwnProperty.call(dreamApp.serializers, serializerKey)) {
+                const serializerClass = dreamApp.serializers[serializerKey];
+                if (typeof serializerClass === 'function' && serializerClass.isDreamSerializer) {
+                    return new serializerClass(data).passthrough(this.defaultSerializerPassthrough).render();
+                }
+                else {
+                    throw new Error(`
+A serializer key was detected, but the server was unable to identify an associated serializer class matching the key.
+The key in question is: "${serializerKey}"`);
+                }
+            }
+        }
+        return data;
+    }
+    json(data, opts = {}) {
+        if (Array.isArray(data))
+            return this.res.json(data.map(d => 
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            this.singleObjectJson(d, opts)));
+        return this.res.json(this.singleObjectJson(data, opts));
+    }
+    defaultSerializerPassthrough = {};
+    serializerPassthrough(passthrough) {
+        this.defaultSerializerPassthrough = {
+            ...this.defaultSerializerPassthrough,
+            ...passthrough,
+        };
+    }
+    respond(data = {}, opts = {}) {
+        const openapiData = this.constructor.openapi[this.action];
+        this.res.status(openapiData?.['status'] || 200);
+        this.json(data, opts);
+    }
+    send({ status = 200, body = undefined,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+     } = {}) {
+        // enums can also do a reverse-lookup based on values, so if e.g. 200 is passed as status,
+        // the lookup of HttpStatusCodeMap[status as HttpStatusSymbol] would return "ok", rather than undefined.
+        const realStatus = (typeof status_codes_js_1.default[status] === 'string'
+            ? status_codes_js_1.default[status_codes_js_1.default[status]]
+            : status_codes_js_1.default[status]);
+        this.res.status(realStatus).json(body);
+    }
+    redirect(path) {
+        this.res.redirect(path);
+    }
+    // begin: http status codes
+    // 200
+    ok(data = {}, opts = {}) {
+        this.json(data, opts);
+    }
+    // 201
+    created(data = {}, opts = {}) {
+        this.res.status(201);
+        this.json(data, opts);
+    }
+    // 202
+    accepted(data = {}, opts = {}) {
+        this.res.status(202);
+        this.json(data, opts);
+    }
+    // 203
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    nonAuthoritativeInformation(message = undefined) {
+        if (message) {
+            this.res.status(203).json(message);
+        }
+        else {
+            this.res.sendStatus(203);
+        }
+    }
+    // 204
+    noContent() {
+        this.res.sendStatus(204);
+    }
+    // 205
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    resetContent(message = undefined) {
+        this.res.status(205).send(message);
+    }
+    // 208
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    alreadyReported(message = undefined) {
+        this.res.status(208).send(message);
+    }
+    // 301
+    movedPermanently(newLocation) {
+        this.res.redirect(301, newLocation);
+    }
+    // 302
+    found(newLocation) {
+        this.res.redirect(302, newLocation);
+    }
+    // 303
+    seeOther(newLocation) {
+        this.res.redirect(303, newLocation);
+    }
+    // 304
+    notModified(newLocation) {
+        this.res.redirect(304, newLocation);
+    }
+    // 307
+    temporaryRedirect(newLocation) {
+        this.res.redirect(307, newLocation);
+    }
+    // 308
+    permanentRedirect(newLocation) {
+        this.res.redirect(308, newLocation);
+    }
+    // 400
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    badRequest(data = undefined) {
+        throw new BadRequest_js_1.default(data);
+    }
+    // 401
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    unauthorized(message = undefined) {
+        throw new Unauthorized_js_1.default(message);
+    }
+    // 402
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    paymentRequired(message = undefined) {
+        throw new PaymentRequired_js_1.default(message);
+    }
+    // 403
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    forbidden(message = undefined) {
+        throw new Forbidden_js_1.default(message);
+    }
+    // 404
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    notFound(message = undefined) {
+        throw new NotFound_js_1.default(message);
+    }
+    // 405
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    methodNotAllowed(message = undefined) {
+        throw new MethodNotAllowed_js_1.default(message);
+    }
+    // 406
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    notAcceptable(message = undefined) {
+        throw new NotAcceptable_js_1.default(message);
+    }
+    // 407
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    proxyAuthenticationRequired(message = undefined) {
+        throw new ProxyAuthenticationRequired_js_1.default(message);
+    }
+    // 409
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    conflict(message = undefined) {
+        throw new Conflict_js_1.default(message);
+    }
+    // 410
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    gone(message = undefined) {
+        throw new Gone_js_1.default(message);
+    }
+    // 412
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    preconditionFailed(message = undefined) {
+        throw new PreconditionFailed_js_1.default(message);
+    }
+    // 413
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    contentTooLarge(message = undefined) {
+        throw new ContentTooLarge_js_1.default(message);
+    }
+    // 415
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    unsupportedMediaType(message = undefined) {
+        throw new UnsupportedMediaType_js_1.default(message);
+    }
+    // 417
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    expectationFailed(message = undefined) {
+        throw new ExpectationFailed_js_1.default(message);
+    }
+    // 418
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    imATeampot(message = undefined) {
+        throw new ImATeapot_js_1.default(message);
+    }
+    // 421
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    misdirectedRequest(message = undefined) {
+        throw new MisdirectedRequest_js_1.default(message);
+    }
+    // 422
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    unprocessableContent(data = undefined) {
+        throw new UnprocessableContent_js_1.default(data);
+    }
+    // 423
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    locked(message = undefined) {
+        throw new Locked_js_1.default(message);
+    }
+    // 424
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    failedDependency(message = undefined) {
+        throw new FailedDependency_js_1.default(message);
+    }
+    // 428
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    preconditionRequired(message = undefined) {
+        throw new PreconditionRequired_js_1.default(message);
+    }
+    // 429
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    tooManyRequests(message = undefined) {
+        throw new TooManyRequests_js_1.default(message);
+    }
+    // 431
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    requestHeaderFieldsTooLarge(message = undefined) {
+        throw new RequestHeaderFieldsTooLarge_js_1.default(message);
+    }
+    // 451
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    unavailableForLegalReasons(message = undefined) {
+        throw new UnavailableForLegalReasons_js_1.default(message);
+    }
+    // 500
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    internalServerError(data = undefined) {
+        throw new InternalServerError_js_1.default(data);
+    }
+    // 501
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    notImplemented(message = undefined) {
+        throw new NotImplemented_js_1.default(message);
+    }
+    // 502
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    badGateway(message = undefined) {
+        throw new BadGateway_js_1.default(message);
+    }
+    // 503
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    serviceUnavailable(message = undefined) {
+        throw new ServiceUnavailable_js_1.default(message);
+    }
+    // 504
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    gatewayTimeout(message = undefined) {
+        throw new GatewayTimeout_js_1.default(message);
+    }
+    // 507
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    insufficientStorage(message = undefined) {
+        throw new InsufficientStorage_js_1.default(message);
+    }
+    // 510
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    notExtended(message = undefined) {
+        throw new NotExtended_js_1.default(message);
+    }
+    // end: http status codes
+    async runAction(action) {
+        await this.runBeforeActionsFor(action);
+        if (this.res.headersSent)
+            return;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
+        await this[action]();
+    }
+    async runBeforeActionsFor(action) {
+        const beforeActions = this.constructor.controllerHooks.filter(hook => hook.shouldFireForAction(action));
+        for (const hook of beforeActions) {
+            if (this.res.headersSent)
+                return;
+            if (hook.isStatic) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+                await this.constructor[hook.methodName]();
+            }
+            else {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+                await this[hook.methodName]();
+            }
+        }
+    }
+}
+exports.default = PsychicController;
+class ControllerSerializerIndex {
+    associations = [];
+    add(ControllerClass, SerializerClass, ModelClass) {
+        this.associations.push([ControllerClass, SerializerClass, ModelClass]);
+    }
+    lookupModel(ControllerClass, ModelClass) {
+        return this.associations.find(association => association[0] === ControllerClass && association[2] === ModelClass);
+    }
+    lookupSerializer(ControllerClass, SerializerClass) {
+        return this.associations.find(association => association[0] === ControllerClass && association[1] === SerializerClass);
+    }
+}
+exports.ControllerSerializerIndex = ControllerSerializerIndex;
+exports.controllerSerializerIndex = new ControllerSerializerIndex();

package/dist/cjs/src/encrypt/internal-encrypt.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dream_1 = require("@rvoh/dream");
+const missing_cookie_encryption_options_js_1 = require("../error/encrypt/missing-cookie-encryption-options.js");
+const index_js_1 = require("../psychic-application/index.js");
+class InternalEncrypt {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static encryptCookie(data) {
+        const psychicApp = index_js_1.default.getOrFail();
+        const encryptOpts = psychicApp.encryption?.cookies;
+        if (!encryptOpts)
+            throw new missing_cookie_encryption_options_js_1.default();
+        if (data === null || data === undefined)
+            return null;
+        return this.doEncryption(data, encryptOpts.current);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static decryptCookie(data) {
+        const psychicApp = index_js_1.default.getOrFail();
+        const encryptOpts = psychicApp.encryption?.cookies;
+        if (!encryptOpts)
+            throw new missing_cookie_encryption_options_js_1.default();
+        if (data === null || data === undefined)
+            return null;
+        return this.doDecryption(data, encryptOpts.current, encryptOpts.legacy);
+    }
+    static doEncryption(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    data, encryptionOpts) {
+        return dream_1.Encrypt.encrypt(data, encryptionOpts);
+    }
+    static doDecryption(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    data, encryptionOpts, legacyEncryptionOpts) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        let decrypted = dream_1.Encrypt.decrypt(data, encryptionOpts);
+        if (decrypted === null && legacyEncryptionOpts)
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            decrypted = dream_1.Encrypt.decrypt(data, legacyEncryptionOpts);
+        return decrypted;
+    }
+}
+exports.default = InternalEncrypt;

package/dist/cjs/src/env/Loader.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dotenv = require("dotenv");
+const EnvInternal_js_1 = require("../helpers/EnvInternal.js");
+class EnvLoader {
+    loaded = false;
+    load() {
+        if (this.loaded)
+            return;
+        dotenv.config({ path: EnvInternal_js_1.default.isTest ? '.env.test' : '.env' });
+        this.check();
+    }
+    ensureLoaded() {
+        if (!this.loaded)
+            this.load();
+    }
+    check() {
+        // const missingEnvs: string[] = []
+        // if (!process.env.APP_ENCRYPTION_KEY) missingEnvs.push('APP_ENCRYPTION_KEY')
+        //
+        // if (!!missingEnvs.length)
+        //   throw `Must make sure the following env vars are set before starting the psychic server: \n${missingEnvs.join(",\n  ")}`
+    }
+}
+const envLoader = new EnvLoader();
+exports.default = envLoader;

package/dist/cjs/src/error/db/failed-to-connect.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("./index.js");
+class DBFailedToConnect extends index_js_1.default {
+    constructor(error) {
+        super(`
+Failed to connect to the database using the credentials located at:
+
+  conf/db.ts
+
+Please check that your credentials are valid, and then try again.
+The underlying error that triggered this message was:
+  ${error.message}
+`);
+    }
+}
+exports.default = DBFailedToConnect;

package/dist/cjs/src/error/db/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class DBError extends Error {
+    _message;
+    constructor(message) {
+        super();
+        this._message = message;
+    }
+    get message() {
+        return `
+      A Database error occured, causing psychic to crash. The message recieved was:
+        ${this._message}
+    `;
+    }
+}
+exports.default = DBError;

package/dist/cjs/src/error/db/missing-options.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("./index.js");
+class DBMissingOptions extends index_js_1.default {
+    constructor(error) {
+        super(`
+Failed to locate the database options required to bootstrap your psychic app.
+Please make sure the following file is present in your app:
+
+  conf/db.ts
+
+the underlying error that triggered this message was:
+  ${error.message}
+`);
+    }
+}
+exports.default = DBMissingOptions;