apeframework 0.0.0-dev.2 → 0.0.0-dev.20

package/server/Method.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Method = void 0;
+var Method;
+(function (Method) {
+    Method["DELETE"] = "DELETE";
+    Method["GET"] = "GET";
+    Method["PATCH"] = "PATCH";
+    Method["POST"] = "POST";
+    Method["PUT"] = "PUT";
+})(Method || (exports.Method = Method = {}));

package/server/Method.ts

@@ -0,0 +1,11 @@
+enum Method {
+  DELETE = 'DELETE',
+  GET = 'GET',
+  PATCH = 'PATCH',
+  POST = 'POST',
+  PUT = 'PUT',
+}
+
+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,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenApiFormat = void 0;
+var OpenApiFormat;
+(function (OpenApiFormat) {
+    OpenApiFormat["JSON"] = "json";
+    OpenApiFormat["YAML"] = "yaml";
+})(OpenApiFormat || (exports.OpenApiFormat = OpenApiFormat = {}));

package/server/OpenApiFormat.ts

@@ -0,0 +1,8 @@
+enum OpenApiFormat {
+  JSON = 'json',
+  YAML = 'yaml',
+}
+
+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.ts

@@ -0,0 +1,16 @@
+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/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.ts

@@ -0,0 +1,13 @@
+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/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,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Server = void 0;
+const compress_1 = __importDefault(require("@fastify/compress"));
+const cors_1 = __importDefault(require("@fastify/cors"));
+const response_validation_1 = __importDefault(require("@fastify/response-validation"));
+const swagger_1 = __importDefault(require("@fastify/swagger"));
+const fastify_1 = __importDefault(require("fastify"));
+const OpenApiFormat_1 = require("./OpenApiFormat");
+const getAjv_1 = require("./getAjv");
+class Server {
+    server;
+    host;
+    port;
+    constructor(params) {
+        this.host = params.host;
+        this.port = params.port;
+        this.server = (0, fastify_1.default)();
+        this.server.setValidatorCompiler(({ schema }) => {
+            return (0, getAjv_1.getAjv)(params.formats).compile(schema);
+        });
+        this.server.register(swagger_1.default, {
+            openapi: {
+                openapi: '3.1.0',
+                info: {
+                    title: params.openapi?.name ?? '',
+                    version: params.openapi?.version ?? '',
+                },
+            },
+        });
+        if (params.responseValidation) {
+            this.server.register(response_validation_1.default);
+        }
+        if (params.compression?.enabled) {
+            this.server.register(compress_1.default, {
+                global: true,
+                threshold: params.compression.threshold ?? 1024,
+            });
+        }
+        if (params.cors?.enabled) {
+            this.server.register(cors_1.default, {
+                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_1.OpenApiFormat.YAML,
+        });
+    }
+}
+exports.Server = Server;

package/server/Server.ts

@@ -0,0 +1,134 @@
+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'
+import type { ErrorHandler } from './ErrorHandler'
+import type { Format } from './Format'
+import type { Handler } from './Handler'
+import type { Route } from './Route'
+import type { FastifyInstance } from 'fastify'
+import type { OpenAPIV3 } from 'openapi-types'
+
+class Server {
+  private readonly server: FastifyInstance
+
+  private readonly host: string
+
+  private readonly port: number | undefined
+
+  public 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,
+  }) {
+    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)
+    }
+  }
+
+  public async start(): Promise<string> {
+    return this.server.listen({
+      host: this.host,
+      port: this.port,
+    })
+  }
+
+  public openapi(format: OpenApiFormat): OpenAPIV3.Document {
+    return this.server.swagger({
+      yaml: format === OpenApiFormat.YAML,
+    }) as OpenAPIV3.Document
+  }
+}
+
+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,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAjv = void 0;
+const ajv_1 = require("ajv");
+const fast_uri_1 = __importDefault(require("fast-uri"));
+const getAjv = (formats) => {
+    const ajv = new ajv_1.Ajv({
+        addUsedSchema: false,
+        allErrors: false,
+        coerceTypes: 'array',
+        removeAdditional: true,
+        uriResolver: fast_uri_1.default,
+        useDefaults: true,
+    });
+    if (formats) {
+        formats.forEach((format) => {
+            ajv.addFormat(format.name, format);
+        });
+    }
+    return ajv;
+};
+exports.getAjv = getAjv;

package/server/getAjv.ts

@@ -0,0 +1,26 @@
+import { Ajv } from 'ajv'
+import fastUri from 'fast-uri'
+import type { Format } from './Format'
+
+const getAjv = (formats?: Format[]): Ajv => {
+  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.ts

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

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,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileReadError = void 0;
+const BaseError_1 = require("../../error/BaseError");
+class FileReadError extends BaseError_1.BaseError {
+    constructor(path, message) {
+        super(`failed reading file "${path}": ${message}`);
+    }
+}
+exports.FileReadError = FileReadError;

package/tls/errors/FileReadError.ts

@@ -0,0 +1,11 @@
+import { BaseError } from '../../error/BaseError'
+
+class FileReadError extends BaseError {
+  public constructor(path: string, message: string) {
+    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,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTls = void 0;
+const readFile_1 = require("./readFile");
+const getTls = (tls) => {
+    return tls
+        ? {
+            ...tls.key ? { key: (0, readFile_1.readFile)(tls.key) } : {},
+            ...tls.cert ? { cert: (0, readFile_1.readFile)(tls.cert) } : {},
+            ...tls.ca ? { ca: (0, readFile_1.readFile)(tls.ca) } : {},
+            ...tls.verify === undefined
+                ? {}
+                : { rejectUnauthorized: tls.verify },
+        }
+        : undefined;
+};
+exports.getTls = getTls;

package/tls/getTls.ts

@@ -0,0 +1,24 @@
+import { readFile } from './readFile'
+import type { Tls } from './Tls'
+
+const getTls = (tls?: Tls): {
+  key?: string,
+  cert?: string,
+  ca?: string,
+  rejectUnauthorized?: boolean,
+} | undefined => {
+  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,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readFile = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const FileReadError_1 = require("./errors/FileReadError");
+const readFile = (path) => {
+    try {
+        if (fs_extra_1.default.existsSync(path)) {
+            return fs_extra_1.default.readFileSync(path).toString();
+        }
+    }
+    catch (error) {
+        throw new FileReadError_1.FileReadError(path, error.message);
+    }
+    throw new FileReadError_1.FileReadError(path, 'missing file');
+};
+exports.readFile = readFile;

package/tls/readFile.ts

@@ -0,0 +1,18 @@
+import fs from 'fs-extra'
+import { FileReadError } from './errors/FileReadError'
+
+const readFile = (path: string): string => {
+  try {
+    if (fs.existsSync(path)) {
+      return fs.readFileSync(path).toString()
+    }
+  } catch (error) {
+    throw new FileReadError(path, (error as 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,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRandomHexString = void 0;
+const crypto_1 = require("crypto");
+const getRandomHexString = (length) => {
+    return (0, crypto_1.randomBytes)(length / 2 + 1).toString('hex').substring(0, length);
+};
+exports.getRandomHexString = getRandomHexString;

package/utils/getRandomHexString.ts

@@ -0,0 +1,9 @@
+import { randomBytes } from 'crypto'
+
+const getRandomHexString = (length: number): string => {
+  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,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTimestamp = void 0;
+const getTimestamp = () => {
+    return Math.trunc(Date.now() / 1000);
+};
+exports.getTimestamp = getTimestamp;

package/utils/getTimestamp.ts

@@ -0,0 +1,7 @@
+const getTimestamp = (): number => {
+  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,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidEmail = void 0;
+const emailRegex = /^[^@\s]+@[^@\s]+\.[^@\s]+$/u;
+const isValidEmail = (email) => {
+    return emailRegex.test(email);
+};
+exports.isValidEmail = isValidEmail;

package/utils/isValidEmail.ts

@@ -0,0 +1,9 @@
+const emailRegex = /^[^@\s]+@[^@\s]+\.[^@\s]+$/u
+
+const isValidEmail = (email: string): boolean => {
+  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,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidGeolocation = void 0;
+const isValidGeolocation = (latitude, longitude) => {
+    return latitude >= -90
+        && latitude <= 90
+        && longitude >= -180
+        && longitude <= 180;
+};
+exports.isValidGeolocation = isValidGeolocation;