4runr-os 2.9.121 → 2.9.122

package/apps/gateway/node_modules/@fastify/ajv-compiler/types/index.d.ts

@@ -1,87 +0,0 @@
-import _ajv, { AnySchema, Options as AjvOptions, ValidateFunction, Plugin } from 'ajv'
-import AjvJTD, { JTDOptions } from 'ajv/dist/jtd'
-import type { Options, ErrorObject } from 'ajv'
-import { AnyValidateFunction } from 'ajv/dist/core'
-
-type Ajv = _ajv
-type AjvSerializerGenerator = typeof AjvCompiler
-
-type AjvJTDCompile = AjvJTD['compileSerializer']
-type AjvCompile = (schema: AnySchema, _meta?: boolean) => AnyValidateFunction
-
-type SharedCompilerOptions = {
-  onCreate?: (ajvInstance: Ajv) => void;
-  plugins?: (Plugin<unknown> | [Plugin<unknown>, unknown])[];
-}
-type JdtCompilerOptions = SharedCompilerOptions & {
-  mode: 'JTD';
-  customOptions?: JTDOptions
-}
-type AjvCompilerOptions = SharedCompilerOptions & {
-  mode?: never;
-  customOptions?: AjvOptions
-}
-
-type BuildAjvOrJdtCompilerFromPool = (
-  externalSchemas: { [key: string]: AnySchema | AnySchema[] },
-  options?: JdtCompilerOptions | AjvCompilerOptions
-) => AjvCompile
-
-type BuildJtdSerializerFromPool = (externalSchemas: any, serializerOpts?: { mode?: never; } & JTDOptions) => AjvJTDCompile
-
-declare function AjvCompiler (opts: { jtdSerializer: true }): AjvCompiler.BuildSerializerFromPool
-declare function AjvCompiler (opts?: { jtdSerializer?: false }): AjvCompiler.BuildCompilerFromPool
-
-declare function StandaloneValidator (options: AjvCompiler.StandaloneOptions): AjvCompiler.BuildCompilerFromPool
-
-declare namespace AjvCompiler {
-  export type { Options, ErrorObject }
-  export { Ajv }
-
-  export type BuildSerializerFromPool = BuildJtdSerializerFromPool
-
-  export type BuildCompilerFromPool = BuildAjvOrJdtCompilerFromPool
-
-  export const AjvReference: Symbol
-
-  export enum HttpParts {
-    Body = 'body',
-    Headers = 'headers',
-    Params = 'params',
-    Query = 'querystring',
-  }
-
-  export type RouteDefinition = {
-    method: string,
-    url: string,
-    httpPart: HttpParts,
-    schema?: unknown,
-  }
-
-  export type StandaloneRestoreFunction = (opts: RouteDefinition) => ValidateFunction
-
-  export type StandaloneStoreFunction = (opts: RouteDefinition, schemaValidationCode: string) => void
-
-  export type StandaloneOptionsReadModeOn = {
-    readMode: true;
-    restoreFunction?: StandaloneRestoreFunction
-  }
-
-  export type StandaloneOptionsReadModeOff = {
-    readMode?: false | undefined;
-    storeFunction?: StandaloneStoreFunction;
-  }
-
-  export type StandaloneOptions = StandaloneOptionsReadModeOn | StandaloneOptionsReadModeOff
-
-  export type ValidatorFactory = BuildCompilerFromPool | BuildSerializerFromPool
-
-  export type ValidatorCompiler = ReturnType<ValidatorFactory>
-
-  export { StandaloneValidator }
-
-  export const AjvCompiler: AjvSerializerGenerator
-  export { AjvCompiler as default }
-}
-
-export = AjvCompiler

package/apps/gateway/node_modules/@fastify/ajv-compiler/types/index.test-d.ts

@@ -1,302 +0,0 @@
-import { AnySchemaObject, ValidateFunction } from 'ajv'
-import { AnyValidateFunction } from 'ajv/dist/core'
-import { expectAssignable, expectType } from 'tsd'
-import AjvCompiler, { AjvReference, ValidatorFactory, StandaloneValidator, RouteDefinition, ErrorObject, BuildCompilerFromPool, BuildSerializerFromPool, ValidatorCompiler } from '..'
-import type Ajv from 'ajv'
-
-{
-  const compiler = AjvCompiler({})
-  expectType<BuildCompilerFromPool>(compiler)
-}
-{
-  const compiler = AjvCompiler()
-  expectType<BuildCompilerFromPool>(compiler)
-}
-{
-  const compiler = AjvCompiler({ jtdSerializer: false })
-  expectType<BuildCompilerFromPool>(compiler)
-}
-
-{
-  const factory = AjvCompiler({ jtdSerializer: false })
-  expectType<BuildCompilerFromPool>(factory)
-  factory({}, {
-    onCreate (ajv) {
-      expectType<import('ajv').default>(ajv)
-    }
-  })
-}
-
-{
-  const compiler = AjvCompiler({ jtdSerializer: true })
-  expectType<BuildSerializerFromPool>(compiler)
-}
-const reader = StandaloneValidator({
-  readMode: true,
-  restoreFunction: (route: RouteDefinition) => {
-    expectAssignable<RouteDefinition>(route)
-    return {} as ValidateFunction
-  },
-})
-expectAssignable<ValidatorFactory>(reader)
-
-const writer = StandaloneValidator({
-  readMode: false,
-  storeFunction: (route: RouteDefinition, code: string) => {
-    expectAssignable<RouteDefinition>(route)
-    expectAssignable<string>(code)
-  },
-})
-expectAssignable<ValidatorFactory>(writer)
-
-expectType<unknown>(({} as ErrorObject).data)
-expectType<string>(({} as ErrorObject).instancePath)
-expectType<string>(({} as ErrorObject).keyword)
-expectType<string | undefined>(({} as ErrorObject).message)
-expectType<Record<string, any>>(({} as ErrorObject).params)
-expectType<AnySchemaObject | undefined>(({} as ErrorObject).parentSchema)
-expectType<string | undefined>(({} as ErrorObject).propertyName)
-expectType<unknown>(({} as ErrorObject).schema)
-expectType<string>(({} as ErrorObject).schemaPath)
-
-expectType<Symbol>(AjvReference)
-
-{
-  const jtdSchema = {
-    discriminator: 'version',
-    mapping: {
-      1: {
-        properties: {
-          foo: { type: 'uint8' }
-        }
-      },
-      2: {
-        properties: {
-          foo: { type: 'string' }
-        }
-      }
-    }
-  }
-
-  const externalSchemas1 = {
-    foo: {
-      definitions: {
-        coordinates: {
-          properties: {
-            lat: { type: 'float32' },
-            lng: { type: 'float32' }
-          }
-        }
-      }
-    }
-  }
-
-  const factory = AjvCompiler({ jtdSerializer: true })
-  expectType<BuildSerializerFromPool>(factory)
-  const compiler = factory(externalSchemas1, {})
-  expectAssignable<Function>(compiler)
-  const serializeFunc = compiler({ schema: jtdSchema })
-  expectType<(data: unknown) => string>(serializeFunc)
-  expectType<string>(serializeFunc({ version: '1', foo: 42 }))
-}
-// JTD
-{
-  const factory = AjvCompiler()
-  expectType<BuildCompilerFromPool>(factory)
-
-  const jtdSchema = {
-    discriminator: 'version',
-    mapping: {
-      1: {
-        properties: {
-          foo: { type: 'uint8' }
-        }
-      },
-      2: {
-        properties: {
-          foo: { type: 'string' }
-        }
-      }
-    }
-  }
-
-  const compiler = factory({}, {
-    customOptions: {},
-    mode: 'JTD'
-  })
-  expectAssignable<ValidatorCompiler>(compiler)
-  const validatorFunc = compiler({ schema: jtdSchema })
-  expectAssignable<ValidateFunction>(validatorFunc)
-
-  expectType<boolean | Promise<any>>(validatorFunc({
-    version: '2',
-    foo: []
-  }))
-}
-
-// generate standalone code
-{
-  const base = {
-    $id: 'urn:schema:base',
-    definitions: {
-      hello: { type: 'string' }
-    },
-    type: 'object',
-    properties: {
-      hello: { $ref: '#/definitions/hello' }
-    }
-  }
-
-  const refSchema = {
-    $id: 'urn:schema:ref',
-    type: 'object',
-    properties: {
-      hello: { $ref: 'urn:schema:base#/definitions/hello' }
-    }
-  }
-
-  const endpointSchema = {
-    schema: {
-      $id: 'urn:schema:endpoint',
-      $ref: 'urn:schema:ref'
-    }
-  }
-
-  const schemaMap = {
-    [base.$id]: base,
-    [refSchema.$id]: refSchema
-  }
-
-  const factory = StandaloneValidator({
-    readMode: false,
-    storeFunction (routeOpts, schemaValidationCode) {
-      expectType<RouteDefinition>(routeOpts)
-      expectType<string>(schemaValidationCode)
-    }
-  })
-  expectAssignable<ValidatorFactory>(factory)
-
-  const compiler = factory(schemaMap)
-  expectAssignable<ValidatorCompiler>(compiler)
-  expectAssignable<Function>(compiler(endpointSchema))
-}
-
-{
-  const base = {
-    $id: 'urn:schema:base',
-    definitions: {
-      hello: { type: 'string' }
-    },
-    type: 'object',
-    properties: {
-      hello: { $ref: '#/definitions/hello' }
-    }
-  }
-
-  const refSchema = {
-    $id: 'urn:schema:ref',
-    type: 'object',
-    properties: {
-      hello: { $ref: 'urn:schema:base#/definitions/hello' }
-    }
-  }
-
-  const endpointSchema = {
-    schema: {
-      $id: 'urn:schema:endpoint',
-      $ref: 'urn:schema:ref'
-    }
-  }
-
-  const schemaMap = {
-    [base.$id]: base,
-    [refSchema.$id]: refSchema
-  }
-  const factory = StandaloneValidator({
-    readMode: true,
-    restoreFunction (routeOpts) {
-      expectType<RouteDefinition>(routeOpts)
-      return {} as ValidateFunction
-    }
-  })
-  expectAssignable<ValidatorFactory>(factory)
-
-  const compiler = factory(schemaMap)
-  expectAssignable<ValidatorCompiler>(compiler)
-  expectType<AnyValidateFunction<any>>(compiler(endpointSchema))
-}
-
-// Plugins
-{
-  const factory = AjvCompiler()
-  const compilerFactoryParams = {
-    customOptions: {},
-    plugins: [
-      (ajv: Ajv) => {
-        expectType<Ajv>(ajv)
-        return ajv
-      },
-      (ajv: Ajv, options: unknown) => {
-        expectType<Ajv>(ajv)
-        expectType<unknown>(options)
-        return ajv
-      }
-    ]
-  }
-  expectAssignable<Parameters<BuildCompilerFromPool>>([{}, compilerFactoryParams])
-
-  const compiler = factory({}, {
-    customOptions: {},
-    plugins: [
-      (ajv) => {
-        expectType<Ajv>(ajv)
-        return ajv
-      },
-      (ajv, options) => {
-        expectType<Ajv>(ajv)
-        expectType<unknown>(options)
-        return ajv
-      }
-    ]
-  })
-  expectAssignable<ValidatorCompiler>(compiler)
-}
-// Compiler factory should allow both signatures (mode: JTD and mode omitted)
-{
-  expectAssignable<Parameters<BuildCompilerFromPool>>([{}, {}])
-
-  const ajvPlugin = (ajv: Ajv): Ajv => {
-    expectType<Ajv>(ajv)
-    return ajv
-  }
-  expectAssignable<Parameters<BuildCompilerFromPool>>([{}, { plugins: [ajvPlugin] }])
-
-  expectAssignable<Parameters<BuildCompilerFromPool>>([{}, {
-    mode: 'JTD',
-    customOptions: {
-      removeAdditional: 'all'
-    },
-    plugins: [ajvPlugin]
-  }])
-
-  expectAssignable<Parameters<BuildCompilerFromPool>>([{}, {
-    mode: 'JTD',
-    customOptions: {
-      removeAdditional: 'all'
-    },
-    plugins: [[ajvPlugin, ['string1', 'string2']]]
-  }])
-
-  expectAssignable<Parameters<BuildCompilerFromPool>>([{}, {
-    plugins: [
-      ajvPlugin,
-      (ajv: Ajv, options: unknown): Ajv => {
-        expectType<Ajv>(ajv)
-        expectType<unknown>(options)
-        return ajv
-      },
-      [ajvPlugin, ['keyword1', 'keyword2']],
-      [ajvPlugin, [{ key: 'value' }]],
-    ]
-  }])
-}

package/apps/gateway/node_modules/@fastify/cors/.editorconfig

@@ -1,8 +0,0 @@
-root = true
-
-[*]
-indent_style = space
-indent_size = 2
-charset = utf-8
-trim_trailing_whitespace = false
-insert_final_newline = false

package/apps/gateway/node_modules/@fastify/cors/.gitattributes

@@ -1,5 +0,0 @@
-# Set the default behavior, in case people don't have core.autocrlf set
-* text=auto
-
-# Require Unix line endings
-* text eol=lf

package/apps/gateway/node_modules/@fastify/cors/.github/dependabot.yml

@@ -1,13 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "monthly"
-    open-pull-requests-limit: 10
-
-  - package-ecosystem: "npm"
-    directory: "/"
-    schedule:
-      interval: "monthly"
-    open-pull-requests-limit: 10

package/apps/gateway/node_modules/@fastify/cors/.github/stale.yml

@@ -1,21 +0,0 @@
-# Number of days of inactivity before an issue becomes stale
-daysUntilStale: 15
-# Number of days of inactivity before a stale issue is closed
-daysUntilClose: 7
-# Issues with these labels will never be considered stale
-exemptLabels:
-  - "discussion"
-  - "feature request"
-  - "bug"
-  - "help wanted"
-  - "plugin suggestion"
-  - "good first issue"
-# Label to use when marking an issue as stale
-staleLabel: stale
-# Comment to post when marking an issue as stale. Set to `false` to disable
-markComment: >
-  This issue has been automatically marked as stale because it has not had
-  recent activity. It will be closed if no further activity occurs. Thank you
-  for your contributions.
-# Comment to post when closing a stale issue. Set to `false` to disable
-closeComment: false

package/apps/gateway/node_modules/@fastify/cors/.github/workflows/ci.yml

@@ -1,33 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches:
-     - main
-     - next
-     - 'v*'
-    paths-ignore:
-      - 'docs/**'
-      - '*.md'
-  pull_request:
-    paths-ignore:
-      - 'docs/**'
-      - '*.md'
-
-# This allows a subsequently queued workflow run to interrupt previous runs
-concurrency:
-    group: "${{ github.workflow }}-${{ github.event.pull_request.head.label || github.head_ref || github.ref }}"
-    cancel-in-progress: true
-
-permissions:
-  contents: read
-
-jobs:
-  test:
-    permissions:
-      contents: write
-      pull-requests: write
-    uses: fastify/workflows/.github/workflows/plugins-ci.yml@v5
-    with:
-      license-check: true
-      lint: true

package/apps/gateway/node_modules/@fastify/cors/LICENSE

@@ -1,23 +0,0 @@
-MIT License
-
-Copyright (c) 2018-present The Fastify team
-
-The Fastify team members are listed at https://github.com/fastify/fastify#team.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.