apeframework 0.0.0-dev.2 → 0.0.0-dev.21

package/pwd/errors/HashRoundsError.js

@@ -0,0 +1,7 @@
+import { BaseError } from '../../error/BaseError';
+class HashRoundsError extends BaseError {
+    constructor(hashRounds) {
+        super(`invalid hash rounds "${hashRounds}"`);
+    }
+}
+export { HashRoundsError, };

package/pwd/validateHashRounds.d.ts

@@ -0,0 +1,2 @@
+declare const validateHashRounds: (hashRounds: number) => void;
+export { validateHashRounds, };

package/pwd/validateHashRounds.js

@@ -0,0 +1,7 @@
+import { HashRoundsError } from './errors/HashRoundsError';
+const validateHashRounds = (hashRounds) => {
+    if (hashRounds < 1) {
+        throw new HashRoundsError(hashRounds);
+    }
+};
+export { validateHashRounds, };

package/server/ErrorHandler.d.ts

@@ -0,0 +1,3 @@
+import type { FastifyError, FastifyReply, FastifyRequest } from 'fastify';
+type ErrorHandler = (error: FastifyError, request: FastifyRequest, response: FastifyReply) => Promise<void>;
+export { type ErrorHandler, };

package/server/ErrorHandler.js

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

package/server/Format.d.ts

@@ -0,0 +1,9 @@
+import type { FormatDefinition } from 'ajv';
+type Format = NumberFormat | StringFormat;
+interface NumberFormat extends FormatDefinition<number> {
+    name: string;
+}
+interface StringFormat extends FormatDefinition<string> {
+    name: string;
+}
+export { type Format, };

package/server/Format.js

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

package/server/Handler.d.ts

@@ -0,0 +1,3 @@
+import type { FastifyReply, FastifyRequest } from 'fastify';
+type Handler = (request: FastifyRequest, response: FastifyReply) => Promise<void>;
+export { type Handler, };

package/server/Handler.js

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

package/server/Method.d.ts

@@ -0,0 +1,8 @@
+declare enum Method {
+    DELETE = "DELETE",
+    GET = "GET",
+    PATCH = "PATCH",
+    POST = "POST",
+    PUT = "PUT"
+}
+export { Method, };

package/server/Method.js

@@ -0,0 +1,9 @@
+var Method;
+(function (Method) {
+    Method["DELETE"] = "DELETE";
+    Method["GET"] = "GET";
+    Method["PATCH"] = "PATCH";
+    Method["POST"] = "POST";
+    Method["PUT"] = "PUT";
+})(Method || (Method = {}));
+export { Method, };

package/server/OpenApiFormat.d.ts

@@ -0,0 +1,5 @@
+declare enum OpenApiFormat {
+    JSON = "json",
+    YAML = "yaml"
+}
+export { OpenApiFormat, };

package/server/OpenApiFormat.js

@@ -0,0 +1,6 @@
+var OpenApiFormat;
+(function (OpenApiFormat) {
+    OpenApiFormat["JSON"] = "json";
+    OpenApiFormat["YAML"] = "yaml";
+})(OpenApiFormat || (OpenApiFormat = {}));
+export { OpenApiFormat, };

package/server/Route.d.ts

@@ -0,0 +1,12 @@
+import type { Handler } from './Handler';
+import type { Method } from './Method';
+import type { Schema } from './Schema';
+interface Route {
+    path: string;
+    method: Method;
+    name?: string;
+    description?: string;
+    schema: Schema;
+    handler: Handler;
+}
+export { type Route, };

package/server/Route.js

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

package/server/Schema.d.ts

@@ -0,0 +1,9 @@
+import type { OpenAPIV3 } from 'openapi-types';
+interface Schema {
+    params?: OpenAPIV3.SchemaObject;
+    query?: OpenAPIV3.SchemaObject;
+    headers?: OpenAPIV3.SchemaObject;
+    body?: OpenAPIV3.SchemaObject;
+    response?: Record<number, OpenAPIV3.SchemaObject>;
+}
+export { type Schema, };

package/server/Schema.js

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

package/server/Server.d.ts

@@ -0,0 +1,37 @@
+import { OpenApiFormat } from './OpenApiFormat';
+import type { ErrorHandler } from './ErrorHandler';
+import type { Format } from './Format';
+import type { Handler } from './Handler';
+import type { Route } from './Route';
+import type { OpenAPIV3 } from 'openapi-types';
+declare class Server {
+    private readonly server;
+    private readonly host;
+    private readonly port;
+    constructor(params: {
+        host: string;
+        port?: number;
+        routes: Route[];
+        formats?: Format[];
+        openapi?: {
+            name?: string;
+            version?: string;
+        };
+        responseValidation?: boolean;
+        compression?: {
+            enabled?: boolean;
+            threshold?: number;
+        };
+        cors?: {
+            enabled?: boolean;
+            origins?: string[];
+        };
+        onRequest?: Handler;
+        onResponse?: Handler;
+        onNotFound?: Handler;
+        onError?: ErrorHandler;
+    });
+    start(): Promise<string>;
+    openapi(format: OpenApiFormat): OpenAPIV3.Document;
+}
+export { Server, };

package/server/Server.js

@@ -0,0 +1,86 @@
+import compress from '@fastify/compress';
+import cors from '@fastify/cors';
+import responseValidation from '@fastify/response-validation';
+import swagger from '@fastify/swagger';
+import fastify from 'fastify';
+import { OpenApiFormat } from './OpenApiFormat';
+import { getAjv } from './getAjv';
+class Server {
+    server;
+    host;
+    port;
+    constructor(params) {
+        this.host = params.host;
+        this.port = params.port;
+        this.server = fastify();
+        this.server.setValidatorCompiler(({ schema }) => {
+            return getAjv(params.formats).compile(schema);
+        });
+        this.server.register(swagger, {
+            openapi: {
+                openapi: '3.1.0',
+                info: {
+                    title: params.openapi?.name ?? '',
+                    version: params.openapi?.version ?? '',
+                },
+            },
+        });
+        if (params.responseValidation) {
+            this.server.register(responseValidation);
+        }
+        if (params.compression?.enabled) {
+            this.server.register(compress, {
+                global: true,
+                threshold: params.compression.threshold ?? 1024,
+            });
+        }
+        if (params.cors?.enabled) {
+            this.server.register(cors, {
+                origin: params.cors.origins,
+            });
+        }
+        this.server.register((server, options, done) => {
+            params.routes.forEach((route) => {
+                server.route({
+                    url: route.path,
+                    method: route.method,
+                    schema: {
+                        summary: route.name ?? route.path,
+                        description: route.description,
+                        ...route.schema.params ? { params: route.schema.params } : {},
+                        ...route.schema.query ? { query: route.schema.query } : {},
+                        ...route.schema.headers ? { headers: route.schema.headers } : {},
+                        ...route.schema.body ? { body: route.schema.body } : {},
+                        ...route.schema.response ? { response: route.schema.response } : {},
+                    },
+                    handler: route.handler,
+                });
+            });
+            done();
+        });
+        if (params.onRequest) {
+            this.server.addHook('onRequest', params.onRequest);
+        }
+        if (params.onResponse) {
+            this.server.addHook('onResponse', params.onResponse);
+        }
+        if (params.onNotFound) {
+            this.server.setNotFoundHandler(params.onNotFound);
+        }
+        if (params.onError) {
+            this.server.setErrorHandler(params.onError);
+        }
+    }
+    async start() {
+        return this.server.listen({
+            host: this.host,
+            port: this.port,
+        });
+    }
+    openapi(format) {
+        return this.server.swagger({
+            yaml: format === OpenApiFormat.YAML,
+        });
+    }
+}
+export { Server, };

package/server/getAjv.d.ts

@@ -0,0 +1,4 @@
+import { Ajv } from 'ajv';
+import type { Format } from './Format';
+declare const getAjv: (formats?: Format[]) => Ajv;
+export { getAjv, };

package/server/getAjv.js

@@ -0,0 +1,19 @@
+import { Ajv } from 'ajv';
+import fastUri from 'fast-uri';
+const getAjv = (formats) => {
+    const ajv = new Ajv({
+        addUsedSchema: false,
+        allErrors: false,
+        coerceTypes: 'array',
+        removeAdditional: true,
+        uriResolver: fastUri,
+        useDefaults: true,
+    });
+    if (formats) {
+        formats.forEach((format) => {
+            ajv.addFormat(format.name, format);
+        });
+    }
+    return ajv;
+};
+export { getAjv, };

package/tls/Tls.d.ts

@@ -0,0 +1,7 @@
+interface Tls {
+    key?: string;
+    cert?: string;
+    ca?: string;
+    verify?: boolean;
+}
+export { type Tls, };

package/tls/Tls.js

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

package/tls/errors/FileReadError.d.ts

@@ -0,0 +1,5 @@
+import { BaseError } from '../../error/BaseError';
+declare class FileReadError extends BaseError {
+    constructor(path: string, message: string);
+}
+export { FileReadError, };

package/tls/errors/FileReadError.js

@@ -0,0 +1,7 @@
+import { BaseError } from '../../error/BaseError';
+class FileReadError extends BaseError {
+    constructor(path, message) {
+        super(`failed reading file "${path}": ${message}`);
+    }
+}
+export { FileReadError, };

package/tls/getTls.d.ts

@@ -0,0 +1,8 @@
+import type { Tls } from './Tls';
+declare const getTls: (tls?: Tls) => {
+    key?: string;
+    cert?: string;
+    ca?: string;
+    rejectUnauthorized?: boolean;
+} | undefined;
+export { getTls, };

package/tls/getTls.js

@@ -0,0 +1,14 @@
+import { readFile } from './readFile';
+const getTls = (tls) => {
+    return tls
+        ? {
+            ...tls.key ? { key: readFile(tls.key) } : {},
+            ...tls.cert ? { cert: readFile(tls.cert) } : {},
+            ...tls.ca ? { ca: readFile(tls.ca) } : {},
+            ...tls.verify === undefined
+                ? {}
+                : { rejectUnauthorized: tls.verify },
+        }
+        : undefined;
+};
+export { getTls, };

package/tls/readFile.d.ts

@@ -0,0 +1,2 @@
+declare const readFile: (path: string) => string;
+export { readFile, };

package/tls/readFile.js

@@ -0,0 +1,14 @@
+import fs from 'fs-extra';
+import { FileReadError } from './errors/FileReadError';
+const readFile = (path) => {
+    try {
+        if (fs.existsSync(path)) {
+            return fs.readFileSync(path).toString();
+        }
+    }
+    catch (error) {
+        throw new FileReadError(path, error.message);
+    }
+    throw new FileReadError(path, 'missing file');
+};
+export { readFile, };

package/utils/getRandomHexString.d.ts

@@ -0,0 +1,2 @@
+declare const getRandomHexString: (length: number) => string;
+export { getRandomHexString, };

package/utils/getRandomHexString.js

@@ -0,0 +1,5 @@
+import { randomBytes } from 'crypto';
+const getRandomHexString = (length) => {
+    return randomBytes(length / 2 + 1).toString('hex').substring(0, length);
+};
+export { getRandomHexString, };

package/utils/getTimestamp.d.ts

@@ -0,0 +1,2 @@
+declare const getTimestamp: () => number;
+export { getTimestamp, };

package/utils/getTimestamp.js

@@ -0,0 +1,4 @@
+const getTimestamp = () => {
+    return Math.trunc(Date.now() / 1000);
+};
+export { getTimestamp, };

package/utils/isValidEmail.d.ts

@@ -0,0 +1,2 @@
+declare const isValidEmail: (email: string) => boolean;
+export { isValidEmail, };

package/utils/isValidEmail.js

@@ -0,0 +1,5 @@
+const emailRegex = /^[^@\s]+@[^@\s]+\.[^@\s]+$/u;
+const isValidEmail = (email) => {
+    return emailRegex.test(email);
+};
+export { isValidEmail, };

package/utils/isValidGeolocation.d.ts

@@ -0,0 +1,2 @@
+declare const isValidGeolocation: (latitude: number, longitude: number) => boolean;
+export { isValidGeolocation, };

package/utils/isValidGeolocation.js

@@ -0,0 +1,7 @@
+const isValidGeolocation = (latitude, longitude) => {
+    return latitude >= -90
+        && latitude <= 90
+        && longitude >= -180
+        && longitude <= 180;
+};
+export { isValidGeolocation, };

package/utils/isValidHexString.d.ts

@@ -0,0 +1,2 @@
+declare const isValidHexString: (string: string) => boolean;
+export { isValidHexString, };

package/utils/isValidHexString.js

@@ -0,0 +1,5 @@
+const hexStringRegex = /^[0-9a-f]*$/u;
+const isValidHexString = (string) => {
+    return hexStringRegex.test(string);
+};
+export { isValidHexString, };

package/utils/isValidIsoDate.d.ts

@@ -0,0 +1,2 @@
+declare const isValidIsoDate: (date: string) => boolean;
+export { isValidIsoDate, };

package/utils/isValidIsoDate.js

@@ -0,0 +1,5 @@
+const isValidIsoDate = (date) => {
+    const d = new Date(date);
+    return !isNaN(d.getTime()) && date === d.toISOString();
+};
+export { isValidIsoDate, };

package/utils/isValidJwtToken.d.ts

@@ -0,0 +1,2 @@
+declare const isValidJwtToken: (token: string) => boolean;
+export { isValidJwtToken, };

package/utils/isValidJwtToken.js

@@ -0,0 +1,5 @@
+const jwtTokenRegex = /^[0-9A-Za-z-_]+\.[0-9A-Za-z-_]+\.[0-9A-Za-z-_]+$/u;
+const isValidJwtToken = (token) => {
+    return jwtTokenRegex.test(token);
+};
+export { isValidJwtToken, };

package/utils/isValidUrl.d.ts

@@ -0,0 +1,2 @@
+declare const isValidUrl: (url: string) => boolean;
+export { isValidUrl, };

package/utils/isValidUrl.js

@@ -0,0 +1,16 @@
+const isValidUrl = (url) => {
+    try {
+        const parsed = new URL(url);
+        if (!['http:', 'https:'].includes(parsed.protocol)) {
+            return false;
+        }
+        if (!url.startsWith(`${parsed.protocol}//`)) {
+            return false;
+        }
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+};
+export { isValidUrl, };

package/utils/isValidUuid.d.ts

@@ -0,0 +1,2 @@
+declare const isValidUuid: (uuid: string) => boolean;
+export { isValidUuid, };

package/utils/isValidUuid.js

@@ -0,0 +1,5 @@
+const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/u;
+const isValidUuid = (uuid) => {
+    return uuidRegex.test(uuid);
+};
+export { isValidUuid, };

package/utils/wait.d.ts

@@ -0,0 +1,2 @@
+declare const wait: (milliseconds: number) => Promise<void>;
+export { wait, };

package/utils/wait.js

@@ -0,0 +1,6 @@
+const wait = async (milliseconds) => {
+    return new Promise((resolve) => {
+        setTimeout(resolve, milliseconds);
+    });
+};
+export { wait, };

package/api/api.d.ts

@@ -1,7 +0,0 @@
-import { OpenAPI } from 'openapi-types';
-export interface Api {
-    start: () => Promise<void>;
-    close: () => Promise<void>;
-    getUrl: () => string;
-    doc: () => OpenAPI.Document;
-}

package/api/api.js

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

package/api/api.ts

@@ -1,8 +0,0 @@
-import { OpenAPI } from 'openapi-types'
-
-export interface Api {
-  start: () => Promise<void>,
-  close: () => Promise<void>,
-  getUrl: () => string,
-  doc: () => OpenAPI.Document,
-}

package/api/auth.d.ts

@@ -1,9 +0,0 @@
-export declare const tokenType = "authorization";
-export declare const headerRegex: RegExp;
-export declare const bearerPrefix = "Bearer ";
-declare const _default: {
-    bearerPrefix: string;
-    headerRegex: RegExp;
-    tokenType: string;
-};
-export default _default;

package/api/auth.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.bearerPrefix = exports.headerRegex = exports.tokenType = void 0;
-exports.tokenType = 'authorization';
-exports.headerRegex = /^Bearer [0-9A-Za-z]+\.[0-9A-Za-z]+\.[0-9A-Za-z-_]+$/;
-exports.bearerPrefix = 'Bearer ';
-exports.default = {
-    bearerPrefix: exports.bearerPrefix,
-    headerRegex: exports.headerRegex,
-    tokenType: exports.tokenType,
-};

package/api/auth.ts

@@ -1,9 +0,0 @@
-export const tokenType = 'authorization'
-export const headerRegex = /^Bearer [0-9A-Za-z]+\.[0-9A-Za-z]+\.[0-9A-Za-z-_]+$/
-export const bearerPrefix = 'Bearer '
-
-export default {
-  bearerPrefix,
-  headerRegex,
-  tokenType,
-}

package/api/config.d.ts

@@ -1,13 +0,0 @@
-import type { FastifyCorsOptions as CorsOptions } from '@fastify/cors';
-import type { FastifyListenOptions as ListenOptions, FastifyServerOptions as ServerOptions } from 'fastify';
-import type { Options as ResponseValidationOptions } from '@fastify/response-validation';
-declare const _default: {
-    name: string;
-    version: string;
-    listenOptions: ListenOptions;
-    serverOptions: ServerOptions;
-    corsOptions: CorsOptions;
-    swaggerOptions: import("@fastify/swagger").FastifyDynamicSwaggerOptions;
-    responseValidationOptions: ResponseValidationOptions;
-};
-export default _default;

package/api/config.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var config_1 = require("../config");
-var config = (0, config_1.getConfig)();
-if (!config.apiName) {
-    throw new Error('api: name not provided');
-}
-if (!config.apiVersion) {
-    throw new Error('api: version not provided');
-}
-if (!config.apiHost) {
-    throw new Error('api: host not provided');
-}
-if (!config.apiPort) {
-    throw new Error('api: port not provided');
-}
-if (!config.apiConnectionTimeout) {
-    throw new Error('api: connection timeout not provided');
-}
-if (!config.apiRequestTimeout) {
-    throw new Error('api: request timeout not provided');
-}
-if (!config.apiKeepAliveTimeout) {
-    throw new Error('api: keep alive timeout not provided');
-}
-if (!config.apiBodyLimit) {
-    throw new Error('api: body limit not provided');
-}
-var listenOptions = {
-    host: config.apiHost,
-    port: config.apiRandomPort ? undefined : config.apiPort,
-};
-var serverOptions = {
-    connectionTimeout: config.apiConnectionTimeout,
-    requestTimeout: config.apiRequestTimeout,
-    keepAliveTimeout: config.apiKeepAliveTimeout,
-    bodyLimit: config.apiBodyLimit,
-};
-var corsOptions = {};
-var swaggerOptions = {
-    openapi: {
-        info: {
-            title: "".concat(config.apiName, " API Documentation"),
-            version: config.apiVersion,
-        },
-    },
-};
-var responseValidationOptions = {
-    responseValidation: config.apiResponseValidation,
-};
-exports.default = {
-    name: config.apiName,
-    version: config.apiVersion,
-    listenOptions: listenOptions,
-    serverOptions: serverOptions,
-    corsOptions: corsOptions,
-    swaggerOptions: swaggerOptions,
-    responseValidationOptions: responseValidationOptions,
-};