@aptly-as/sdk-nodejs 0.0.1

package/README.md

@@ -0,0 +1,15 @@
+# Aptly web sdk
+
+SDK library for Node.js libraries.
+
+## Installation
+```
+pnpm install
+pnpm dev
+```
+
+## Code
+
+### AptlyResponseError
+Handle errors for backend. Create simple to more complex errors with provided functions.\
+Use `toJSON` to return a nice formated error to frontend.

package/error/ResponseError.d.ts

@@ -0,0 +1,46 @@
+import { AptlyErrorCode } from '@aptly-as/types';
+export interface AptlyResponseErrorJson extends Omit<AptlyResponseErrorData, 'errors'> {
+    errors?: AptlyResponseErrorJsonSimple[];
+}
+export interface AptlyResponseErrorData {
+    id: string;
+    status: number;
+    title: string;
+    message: string;
+    code?: AptlyErrorCode;
+    link?: string;
+    detail?: string;
+    errors?: AptlyResponseError[];
+}
+export type AptlyResponseErrorJsonSimple = Pick<AptlyResponseErrorJson, 'title' | 'message' | 'code' | 'link' | 'detail'>;
+export interface AptlyResponseErrorProps extends Partial<Omit<AptlyResponseErrorData, 'title' | 'status'>> {
+    level?: AptlyLogLevel;
+    error?: any;
+}
+export declare enum AptlyLogLevel {
+    Fatal = "fatal",
+    Error = "error",
+    Warning = "warn",
+    Info = "info",
+    Debug = "debug",
+    Trace = "trace"
+}
+export declare class AptlyResponseError extends Error {
+    readonly status: number;
+    private props;
+    name: string;
+    private _id;
+    static ofError(error: Error): AptlyResponseError;
+    constructor(status: number, message: string, props?: AptlyResponseErrorProps);
+    get level(): AptlyLogLevel;
+    get errors(): AptlyResponseError[];
+    get code(): AptlyErrorCode;
+    get link(): string;
+    get detail(): string;
+    get id(): string;
+    setId(id: string): this;
+    toJSON<T extends boolean>(simple?: T): T extends true ? AptlyResponseErrorJsonSimple : AptlyResponseErrorJson;
+    log(): this;
+    toString(): string;
+    res(_request: any, _response: any): void;
+}

package/error/ResponseError.js

@@ -0,0 +1,89 @@
+import { AptlyErrorCode } from '@aptly-as/types';
+export var AptlyLogLevel;
+(function (AptlyLogLevel) {
+    AptlyLogLevel["Fatal"] = "fatal";
+    AptlyLogLevel["Error"] = "error";
+    AptlyLogLevel["Warning"] = "warn";
+    AptlyLogLevel["Info"] = "info";
+    AptlyLogLevel["Debug"] = "debug";
+    AptlyLogLevel["Trace"] = "trace";
+})(AptlyLogLevel || (AptlyLogLevel = {}));
+export class AptlyResponseError extends Error {
+    static ofError(error) {
+        const responseError = Object.setPrototypeOf(error, AptlyResponseError.prototype);
+        responseError.status = 500;
+        return Object.assign(responseError, {
+            name: 'ResponseError',
+            props: {
+                code: AptlyErrorCode.Default,
+                level: AptlyLogLevel.Error,
+                errors: [],
+                detail: '',
+                link: '',
+            },
+        });
+    }
+    constructor(status, message, props = {}) {
+        super(message);
+        this.status = status;
+        this.props = props;
+        this.name = 'ResponseError';
+        this._id = '';
+        this.status = status;
+        this._id = props.id || '';
+    }
+    get level() {
+        return this.props.level || AptlyLogLevel.Warning;
+    }
+    get errors() {
+        return this.props.errors || [];
+    }
+    get code() {
+        return this.props.code || AptlyErrorCode.Default;
+    }
+    get link() {
+        return this.props.link || '';
+    }
+    get detail() {
+        return this.props.detail || '';
+    }
+    get id() {
+        return this._id;
+    }
+    setId(id) {
+        this._id = id;
+        return this;
+    }
+    toJSON(simple) {
+        if (simple) {
+            return {
+                code: this.code,
+                title: this.message,
+                message: this.message,
+                detail: this.detail,
+                link: this.link,
+            };
+        }
+        return {
+            id: this._id,
+            status: this.status,
+            code: this.code,
+            title: this.message,
+            message: this.message,
+            detail: this.detail,
+            link: this.link,
+            errors: this.errors?.map((x) => x.toJSON(true)),
+        };
+    }
+    log() {
+        console.error(this);
+        return this;
+    }
+    toString() {
+        return `${this.code}: ${this.message}`;
+    }
+    res(_request, _response) {
+        throw new Error('AptlyResponseError res function has not been implemented.');
+    }
+}
+//# sourceMappingURL=ResponseError.js.map

package/error/ResponseError.test.d.ts

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

package/error/ResponseError.test.js

@@ -0,0 +1,54 @@
+import { AptlyErrorCode } from '@aptly-as/types';
+import { describe, expect, test } from 'vitest';
+import { createGeneralTestError } from '../test/test.utils.js';
+import { AptlyResponseError, AptlyLogLevel } from './ResponseError.js';
+describe('AptlyResponseError', () => {
+    test('should init', () => {
+        const error = new AptlyResponseError(500, 'message', {
+            errors: [],
+            error: new Error(),
+            level: AptlyLogLevel.Debug,
+            id: 'id',
+            detail: 'Some detail here',
+            link: 'link for helping to debug',
+        });
+        expect(error).instanceof(AptlyResponseError);
+    });
+    test('should create json for body', () => {
+        const responseError = AptlyResponseError.ofError(new Error('JSON'));
+        const json = responseError.toJSON();
+        expect(json).to.have.keys('id', 'code', 'detail', 'errors', 'status', 'title', 'message', 'link');
+    });
+    test('should create simple json for body', () => {
+        const responseError = AptlyResponseError.ofError(new Error('JSON'));
+        const json = responseError.toJSON(true);
+        expect(json).to.have.keys('code', 'detail', 'title', 'message', 'link');
+    });
+    test('should be created from normal error', () => {
+        const error = createGeneralTestError();
+        const responseError = AptlyResponseError.ofError(error).setId('id');
+        expect(error).instanceof(AptlyResponseError);
+        expect(responseError).instanceof(AptlyResponseError);
+        expect(responseError.id).to.equal('id');
+        expect(responseError.level).to.equal(AptlyLogLevel.Error);
+        expect(responseError.code).to.equal(AptlyErrorCode.Default);
+        expect(responseError.link).to.equal('');
+        expect(responseError.detail).to.equal('');
+        expect(Array.isArray(responseError.errors)).toBeTruthy();
+        expect(responseError.log).toBeTypeOf('function');
+        expect(responseError.toString).toBeTypeOf('function');
+        expect(responseError.toJSON).toBeTypeOf('function');
+        expect(responseError.stack).to.contain('\\test\\test.utils.ts');
+        expect(responseError.toJSON()).to.deep.equal({
+            id: 'id',
+            status: 500,
+            code: AptlyErrorCode.Default,
+            title: 'Error from another file',
+            message: 'Error from another file',
+            detail: '',
+            link: '',
+            errors: [],
+        });
+    });
+});
+//# sourceMappingURL=ResponseError.test.js.map

package/index.d.ts

@@ -0,0 +1 @@
+export * from './error/ResponseError.js';

package/index.js

@@ -0,0 +1,2 @@
+export * from './error/ResponseError.js';
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@aptly-as/sdk-nodejs",
+  "version": "0.0.1",
+  "description": "Aptly SDK library for node.js applications",
+  "type": "module",
+  "main": "index.js",
+  "author": "Emil Andreas Olsen <emil@aptly.as>",
+  "license": "ISC",
+  "devDependencies": {
+    "@aptly-as/types": "^2.7.15",
+    "@vitest/ui": "^2.1.8",
+    "husky": "^9.1.7",
+    "lint-staged": "^15.2.11",
+    "prettier": "^3.4.2",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  },
+  "peerDependencies": {
+    "@aptly-as/types": "*"
+  },
+  "lint-staged": {
+    "**/*": "prettier --write --ignore-unknown"
+  },
+  "scripts": {
+    "start": "tsc --incremental --watch",
+    "build": "tsc",
+    "test": "vitest",
+    "test:ui": "vitest --ui --api 9527",
+    "test:run": "vitest run",
+    "prepublish": "npm run build",
+    "postversion": "git push && git push --tags"
+  }
+}