apeframework 0.0.0-dev.20 → 0.0.0-dev.21

package/mailer/validateEventGeolocation.ts

@@ -1,15 +0,0 @@
-import { isValidGeolocation } from 'utils/isValidGeolocation'
-import { EventGeolocationError } from './errors/EventGeolocationError'
-
-const validateEventGeolocation = (
-  latitude: number,
-  longitude: number,
-): void => {
-  if (!isValidGeolocation(latitude, longitude)) {
-    throw new EventGeolocationError(latitude, longitude)
-  }
-}
-
-export {
-  validateEventGeolocation,
-}

package/mailer/validateEventUrl.ts

@@ -1,12 +0,0 @@
-import { isValidUrl } from 'utils/isValidUrl'
-import { EventUrlError } from './errors/EventUrlError'
-
-const validateEventUrl = (url: string): void => {
-  if (!isValidUrl(url)) {
-    throw new EventUrlError(url)
-  }
-}
-
-export {
-  validateEventUrl,
-}

package/mailer/validateListUrl.ts

@@ -1,12 +0,0 @@
-import { isValidUrl } from 'utils/isValidUrl'
-import { ListUrlError } from './errors/ListUrlError'
-
-const validateListUrl = (property: string, url: string): void => {
-  if (!isValidUrl(url)) {
-    throw new ListUrlError(property, url)
-  }
-}
-
-export {
-  validateListUrl,
-}

package/parser/Parser.ts

@@ -1,5 +0,0 @@
-type Parser<Type> = (input: any) => Type
-
-export {
-  type Parser,
-}

package/parser/errors/ParseError.ts

@@ -1,11 +0,0 @@
-import { BaseError } from '../../error/BaseError'
-
-class ParseError extends BaseError {
-  public constructor(type: string) {
-    super(`failed parsing ${type}`)
-  }
-}
-
-export {
-  ParseError,
-}

package/parser/factories/enum/createEnumParser.ts

@@ -1,21 +0,0 @@
-import { ParseError } from '../../errors/ParseError'
-import type { Parser } from '../../Parser'
-
-const createEnumParser = <Type extends Record<string, string | number>>(
-  params: {
-    type: string,
-    enum: Type,
-  },
-): Parser<Type[keyof Type]> => {
-  return (input) => {
-    if (!Object.values(params.enum).includes(input)) {
-      throw new ParseError(params.type)
-    }
-
-    return input
-  }
-}
-
-export {
-  createEnumParser,
-}

package/parser/factories/unit/Unit.ts

@@ -1,8 +0,0 @@
-interface Unit {
-  symbol: string,
-  value: number,
-}
-
-export {
-  type Unit,
-}

package/parser/factories/unit/createUnitParser.ts

@@ -1,50 +0,0 @@
-import { ParseError } from '../../errors/ParseError'
-import { parseNumber } from '../../parseNumber'
-import { parseString } from '../../parseString'
-import type { Unit } from './Unit'
-import type { Parser } from '../../Parser'
-
-const createUnitParser = (params: {
-  type: string,
-  units: Unit[],
-}): Parser<number> => {
-  return (input) => {
-    let string: string
-
-    try {
-      string = parseString(input)
-    } catch (error) {
-      throw new ParseError(params.type)
-    }
-
-    const units: Unit[] = []
-
-    params.units.forEach((u) => {
-      units.push(u, { ...u, symbol: ` ${u.symbol}` })
-    })
-
-    units.sort((a, b) => {
-      return b.symbol.length - a.symbol.length
-    })
-
-    const unit = units.find((u) => {
-      return string.toUpperCase().endsWith(u.symbol.toUpperCase())
-    })
-
-    let number: number
-
-    try {
-      number = parseNumber(
-        string.substring(0, string.length - (unit?.symbol.length ?? 0)),
-      )
-    } catch (error) {
-      throw new ParseError(params.type)
-    }
-
-    return number * (unit?.value ?? 1)
-  }
-}
-
-export {
-  createUnitParser,
-}

package/parser/parseBoolean.ts

@@ -1,33 +0,0 @@
-import { ParseError } from './errors/ParseError'
-import type { Parser } from './Parser'
-
-const parseBoolean: Parser<boolean> = (input) => {
-  if ([
-    true,
-    1,
-    BigInt(1),
-    '1',
-    'TRUE',
-    'true',
-  ].includes(input)) {
-    return true
-  } else if ([
-    undefined,
-    null,
-    false,
-    0,
-    BigInt(0),
-    '',
-    '0',
-    'FALSE',
-    'false',
-  ].includes(input)) {
-    return false
-  }
-
-  throw new ParseError('boolean')
-}
-
-export {
-  parseBoolean,
-}

package/parser/parseBytes.ts

@@ -1,55 +0,0 @@
-import { createUnitParser } from './factories/unit/createUnitParser'
-
-const parseBytes = createUnitParser({
-  type: 'bytes',
-  units: [
-    {
-      symbol: 'B',
-      value: 1,
-    },
-    {
-      symbol: 'kB',
-      value: 1000,
-    },
-    {
-      symbol: 'MB',
-      value: 1000000,
-    },
-    {
-      symbol: 'GB',
-      value: 1000000000,
-    },
-    {
-      symbol: 'TB',
-      value: 1000000000000,
-    },
-    {
-      symbol: 'PB',
-      value: 1000000000000000,
-    },
-    {
-      symbol: 'KiB',
-      value: 1024,
-    },
-    {
-      symbol: 'MiB',
-      value: 131072,
-    },
-    {
-      symbol: 'GiB',
-      value: 134200000,
-    },
-    {
-      symbol: 'TiB',
-      value: 137400000000,
-    },
-    {
-      symbol: 'PiB',
-      value: 140700000000000,
-    },
-  ],
-})
-
-export {
-  parseBytes,
-}

package/parser/parseInteger.ts

@@ -1,23 +0,0 @@
-import { ParseError } from './errors/ParseError'
-import { parseNumber } from './parseNumber'
-import type { Parser } from './Parser'
-
-const parseInteger: Parser<number> = (input) => {
-  let number: number
-
-  try {
-    number = parseNumber(input)
-  } catch (error) {
-    throw new ParseError('integer')
-  }
-
-  if (!Number.isSafeInteger(number)) {
-    throw new ParseError('integer')
-  }
-
-  return number
-}
-
-export {
-  parseInteger,
-}

package/parser/parseMilliseconds.ts

@@ -1,31 +0,0 @@
-import { createUnitParser } from './factories/unit/createUnitParser'
-
-const parseMilliseconds = createUnitParser({
-  type: 'milliseconds',
-  units: [
-    {
-      symbol: 'ms',
-      value: 1,
-    },
-    {
-      symbol: 's',
-      value: 1000,
-    },
-    {
-      symbol: 'm',
-      value: 60000,
-    },
-    {
-      symbol: 'h',
-      value: 3600000,
-    },
-    {
-      symbol: 'd',
-      value: 86400000,
-    },
-  ],
-})
-
-export {
-  parseMilliseconds,
-}

package/parser/parseNumber.ts

@@ -1,22 +0,0 @@
-import { ParseError } from './errors/ParseError'
-import type { Parser } from './Parser'
-
-const parseNumber: Parser<number> = (input) => {
-  if ([undefined, null].includes(input)) {
-    return 0
-  } else if (['object', 'function', 'symbol'].includes(typeof input)) {
-    throw new ParseError('number')
-  }
-
-  const number = Number(input)
-
-  if (!Number.isFinite(number)) {
-    throw new ParseError('number')
-  }
-
-  return number
-}
-
-export {
-  parseNumber,
-}

package/parser/parseString.ts

@@ -1,16 +0,0 @@
-import { ParseError } from './errors/ParseError'
-import type { Parser } from './Parser'
-
-const parseString: Parser<string> = (input) => {
-  if ([undefined, null].includes(input)) {
-    return ''
-  } else if (['object', 'function', 'symbol'].includes(typeof input)) {
-    throw new ParseError('string')
-  }
-
-  return String(input)
-}
-
-export {
-  parseString,
-}

package/pwd/Pwd.ts

@@ -1,31 +0,0 @@
-import bcrypt from 'bcryptjs'
-import { validateHashRounds } from './validateHashRounds'
-
-class Pwd {
-  private readonly hashRounds: number
-
-  public constructor(params: {
-    hashRounds: number,
-  }) {
-    validateHashRounds(params.hashRounds)
-
-    this.hashRounds = params.hashRounds
-  }
-
-  public async hashPassword(
-    password: string,
-  ): Promise<string> {
-    return bcrypt.hashSync(password, this.hashRounds)
-  }
-
-  public async verifyPassword(
-    password: string,
-    hash: string,
-  ): Promise<boolean> {
-    return bcrypt.compareSync(password, hash)
-  }
-}
-
-export {
-  Pwd,
-}

package/pwd/errors/HashRoundsError.ts

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

package/pwd/validateHashRounds.ts

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

package/server/ErrorHandler.ts

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

package/server/Format.ts

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

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

package/server/Method.ts

@@ -1,11 +0,0 @@
-enum Method {
-  DELETE = 'DELETE',
-  GET = 'GET',
-  PATCH = 'PATCH',
-  POST = 'POST',
-  PUT = 'PUT',
-}
-
-export {
-  Method,
-}

package/server/OpenApiFormat.ts

@@ -1,8 +0,0 @@
-enum OpenApiFormat {
-  JSON = 'json',
-  YAML = 'yaml',
-}
-
-export {
-  OpenApiFormat,
-}

package/server/Route.ts

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

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

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

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

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

package/tls/errors/FileReadError.ts

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

@@ -1,24 +0,0 @@
-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,
-}