massimo 0.0.1 → 0.1.1

package/.c8rc

@@ -0,0 +1,6 @@
+{
+  "exclude": [
+    "fixtures/*",
+    "test/*"
+  ]
+}

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,13 @@
+ Copyright 2025 Platformatic
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.

package/README.md

@@ -0,0 +1,13 @@
+# @platformatic/massimo
+
+Check out the full documentation for Massimo on [massimohttp.dev](https://massimohttp.dev).
+
+## Install
+
+```sh
+npm install @platformatic/massimo
+```
+
+## License
+
+Apache 2.0

package/eslint.config.js

@@ -0,0 +1,3 @@
+import neostandard from 'neostandard'
+
+export default neostandard()

package/fastify-plugin.d.ts

@@ -0,0 +1,38 @@
+import { FastifyPluginAsync, FastifyReply, FastifyRequest } from 'fastify'
+import { Dispatcher } from 'undici'
+
+interface Headers {
+  [key: string]: string
+}
+
+export interface GetHeadersOptions {
+  url: URL
+  method: string
+  body: object
+  headers: Headers
+  telemetryHeaders?: Headers
+}
+
+interface PlatformaticClientOptions {
+  url: string
+  path?: string
+  fullResponse: boolean
+  fullRequest: boolean
+  throwOnError: boolean
+  headers?: Headers
+  bodyTimeout?: number
+  headersTimeout?: number
+  validateResponse?: boolean
+  queryParser?: (query: URLSearchParams) => string
+  dispatcher?: Dispatcher
+}
+
+export type PlatformaticClientPluginOptions = PlatformaticClientOptions & {
+  type: 'openapi' | 'graphql'
+  name?: string
+  applicationId?: string
+  getHeaders?: (request: FastifyRequest, reply: FastifyReply, options: GetHeadersOptions) => Promise<Headers>
+}
+
+export const plugin: FastifyPluginAsync<PlatformaticClientPluginOptions>
+export default plugin

package/fastify-plugin.js

@@ -0,0 +1,63 @@
+import { buildGraphQLClient, buildOpenAPIClient } from './index.js'
+import { WrongOptsTypeError } from './lib/errors.js'
+import { kGetHeaders, kTelemetryContext } from './lib/symbols.js'
+
+function capitalize (str) {
+  return str.charAt(0).toUpperCase() + str.slice(1)
+}
+
+export async function plugin (app, opts) {
+  let client = null
+  let getHeaders = null
+
+  if (typeof opts.getHeaders === 'function') {
+    getHeaders = opts.getHeaders
+    opts = { ...opts }
+    opts.getHeaders = undefined
+  }
+
+  if (opts.applicationId && !opts.url) {
+    opts.url = `http://${opts.applicationId}.plt.local`
+  }
+
+  if (opts.type === 'openapi') {
+    client = await buildOpenAPIClient(opts, app.openTelemetry)
+  } else if (opts.type === 'graphql') {
+    if (!opts.url.endsWith('/graphql')) {
+      opts.url += '/graphql'
+    }
+    client = await buildGraphQLClient(opts, app.openTelemetry, app.log)
+  } else {
+    throw new WrongOptsTypeError()
+  }
+
+  let name = opts.name
+  if (!name) {
+    name = 'client'
+  }
+
+  app.decorateRequest(name, null)
+
+  app.decorate('configure' + capitalize(name), function (opts) {
+    getHeaders = opts.getHeaders
+  })
+
+  app.addHook('onRequest', async (req, reply) => {
+    const newClient = Object.create(client)
+
+    if (getHeaders) {
+      newClient[kGetHeaders] = getHeaders.bind(newClient, req, reply)
+    }
+    if (req.span) {
+      newClient[kTelemetryContext] = req.span.context
+    }
+    req[name] = newClient
+  })
+}
+
+plugin[Symbol.for('skip-override')] = true
+plugin[Symbol.for('plugin-meta')] = {
+  name: '@platformatic/client'
+}
+
+export default plugin

package/index.d.ts

@@ -0,0 +1,93 @@
+import { FastifyError } from '@fastify/error'
+import { Dispatcher } from 'undici';
+
+type CodeClasses = 1 | 2 | 3 | 4 | 5;
+type Digit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+type StringAsNumber<T extends string> = T extends `${infer N extends number}` ? N : never;
+type StatusCodes<T extends CodeClasses> = StringAsNumber<`${T}${Digit}${Digit}`>;
+export type StatusCode1xx = StatusCodes<1>;
+export type StatusCode2xx = StatusCodes<2>;
+export type StatusCode3xx = StatusCodes<3>;
+export type StatusCode4xx = StatusCodes<4>;
+export type StatusCode5xx = StatusCodes<5>;
+
+interface Headers {
+  [key: string]: string
+}
+
+export interface GetHeadersOptions {
+  url: URL;
+  method: string;
+  body: object;
+  headers: Headers;
+  telemetryHeaders?: Headers;
+}
+
+interface PlatformaticClientOptions {
+  url: string;
+  path?: string;
+  fullResponse?: boolean;
+  fullRequest?: boolean;
+  throwOnError?: boolean;
+  headers?: Headers;
+  bodyTimeout?: number;
+  headersTimeout?: number;
+  validateResponse?: boolean;
+  queryParser?: (query: URLSearchParams) => string;
+  dispatcher?: Dispatcher;
+}
+
+type BuildOpenAPIClientOptions  = PlatformaticClientOptions & {
+  getHeaders?: (options: GetHeadersOptions) => Promise<Headers>;
+}
+
+interface AbstractLogger {
+  fatal: () => void;
+  error: () => void;
+  warn: () => void;
+  info: () => void;
+  debug: () => void;
+  trace: () => void;
+}
+
+interface BuildGraphQLClientOptions {
+  url: string;
+  headers?: Headers;
+}
+
+interface Parameter {
+  in: string;
+  name: string;
+}
+
+interface MethodMetaInterface {
+  operationId?: string,
+  parameters: Parameter[]
+}
+
+interface BuildGraphQLClientOutput {
+  graphql: <T>() => Promise<T>;
+}
+
+type OpenTelemetry = {
+  startSpanClient?: (urlToCall: URL, method: string, telemetryContext: any) => object
+  endSpanClient?: (span: any, res: any) => void
+  setErrorInSpanClient?: (span: any, err: unknown) => void
+}
+
+export function generateOperationId(path: string, method: string, methodMeta: MethodMetaInterface, all: string[]): string
+export function buildOpenAPIClient<T>(options: BuildOpenAPIClientOptions, openTelemetry?: OpenTelemetry): Promise<T>
+export function buildGraphQLClient(options: BuildGraphQLClientOptions, openTelemetry?: OpenTelemetry, logger?: AbstractLogger): Promise<BuildGraphQLClientOutput>
+export function hasDuplicatedParameters(methodMeta: MethodMetaInterface): boolean
+
+export module errors {
+  export const OptionsUrlRequiredError: () => FastifyError
+  export const FormDataRequiredError: (value: string) => FastifyError
+  export const MissingParamsRequiredError: (value: string) => FastifyError
+  export const WrongOptsTypeError: () => FastifyError
+  export const InvalidResponseSchemaError: (value: string) => FastifyError
+  export const InvalidContentTypeError: (value: string) => FastifyError
+  export const InvalidResponseFormatError: () => FastifyError
+  export const UnexpectedCallFailureError: (value: string) => FastifyError
+}
+

package/index.js

@@ -0,0 +1,505 @@
+import $RefParser from '@apidevtools/json-schema-ref-parser'
+import Ajv from 'ajv'
+import camelCase from 'camelcase'
+import fs from 'fs/promises'
+import { createHash } from 'node:crypto'
+import { join } from 'path'
+import * as undici from 'undici'
+import * as errors from './lib/errors.js'
+import { kGetHeaders, kHeaders, kTelemetryContext } from './lib/symbols.js'
+
+const {
+  FormData,
+  errors: { UndiciError },
+  getGlobalDispatcher,
+  request,
+  interceptors
+} = undici
+
+const validateFunctionCache = {}
+
+function noop () {}
+
+const abstractLogger = {
+  fatal: noop,
+  error: noop,
+  warn: noop,
+  info: noop,
+  debug: noop,
+  trace: noop,
+  done: noop,
+  child () {
+    return abstractLogger
+  }
+}
+
+function computeURLWithoutPath (url) {
+  url = new URL(url)
+  url.pathname = ''
+  return url.toString()
+}
+
+async function buildCallFunction (
+  spec,
+  baseUrl,
+  path,
+  method,
+  methodMeta,
+  openTelemetry,
+  fullRequest,
+  fullResponse,
+  validateResponse,
+  queryParser,
+  bodyTimeout,
+  headersTimeout,
+  dispatcher
+) {
+  if (validateResponse) {
+    await $RefParser.dereference(spec)
+  }
+  const ajv = new Ajv()
+  const url = new URL(baseUrl)
+  method = method.toUpperCase()
+  path = join(url.pathname, path)
+
+  const canHaveBody = method === 'POST' || method === 'PUT' || method === 'PATCH' || method === 'OPTIONS'
+  const pathParams = methodMeta.parameters?.filter(p => p.in === 'path') || []
+  const queryParams = methodMeta.parameters?.filter(p => p.in === 'query') || []
+  const headerParams = methodMeta.parameters?.filter(p => p.in === 'header') || []
+  const forceFullRequest = fullRequest || hasDuplicatedParameters(methodMeta)
+
+  const responses = methodMeta.responses
+  return async function (args) {
+    let headers = this[kHeaders]
+    let telemetryContext = null
+    if (this[kTelemetryContext]) {
+      telemetryContext = this[kTelemetryContext]
+    }
+    let body
+    const query = new URLSearchParams()
+    let pathToCall = path
+    const urlToCall = new URL(url)
+    if (forceFullRequest) {
+      headers = args?.headers
+      body = args?.body || ''
+      for (const param of pathParams) {
+        if (args?.path[param.name] === undefined) {
+          throw new errors.MissingParamsRequiredError(param.name)
+        }
+        pathToCall = pathToCall.replace(`{${param.name}}`, args.path[param.name])
+      }
+
+      for (const param of queryParams) {
+        if (args?.query?.[param.name] !== undefined) {
+          if (isArrayQueryParam(param)) {
+            args.query[param.name].forEach(p => query.append(param.name, p))
+          } else {
+            query.append(param.name, args.query[param.name])
+          }
+        }
+      }
+    } else {
+      body = args instanceof FormData ? args : { ...args } || '' // shallow copy
+      for (const param of pathParams) {
+        if (body[param.name] === undefined) {
+          throw new errors.MissingParamsRequiredError(param.name)
+        }
+        pathToCall = pathToCall.replace(`{${param.name}}`, body[param.name])
+        body[param.name] = undefined
+      }
+
+      for (const param of queryParams) {
+        if (body[param.name] !== undefined) {
+          if (isArrayQueryParam(param)) {
+            body[param.name].forEach(p => query.append(param.name, p))
+          } else {
+            query.append(param.name, body[param.name])
+          }
+          body[param.name] = undefined
+        }
+      }
+
+      for (const param of headerParams) {
+        if (body[param.name] !== undefined) {
+          headers[param.name] = body[param.name]
+          body[param.name] = undefined
+        }
+      }
+    }
+
+    urlToCall.search = queryParser ? queryParser(query) : query.toString()
+    urlToCall.pathname = pathToCall
+
+    const { span, telemetryHeaders } = openTelemetry?.startHTTPSpanClient(
+      urlToCall.toString(),
+      method,
+      telemetryContext
+    ) || { span: null, telemetryHeaders: {} }
+
+    if (this[kGetHeaders]) {
+      const options = { url: urlToCall, method, headers, telemetryHeaders, body }
+      headers = { ...headers, ...(await this[kGetHeaders](options)) }
+    }
+
+    let res
+    try {
+      const requestOptions = {
+        method,
+        headers: {
+          ...headers,
+          ...telemetryHeaders
+        },
+        bodyTimeout,
+        headersTimeout,
+        dispatcher
+      }
+      if (canHaveBody) {
+        const bodyType = getRequestBodyContentType(methodMeta)
+        if (bodyType === 'multipart/form-data') {
+          if (body instanceof FormData) {
+            requestOptions.body = body
+          } else {
+            throw new errors.FormDataRequiredError(`${method} ${path}`)
+          }
+        } else {
+          requestOptions.headers['content-type'] = bodyType
+          requestOptions.body = JSON.stringify(body)
+        }
+      }
+      res = await request(urlToCall, requestOptions)
+      let responseBody
+      const contentType = sanitizeContentType(res.headers['content-type']) || 'application/json'
+      try {
+        if (res.statusCode === 204) {
+          await res.body.dump()
+        } else if (contentType === 'application/json') {
+          responseBody = await res.body.json()
+        } else {
+          responseBody = await res.body.text()
+        }
+      } catch (err) {
+        // maybe the response is a 302, 301, or anything with empty payload
+        responseBody = {}
+      }
+      if (validateResponse) {
+        try {
+          // validate response first
+          const matchingResponse = responses[res.statusCode]
+
+          if (matchingResponse === undefined) {
+            throw new errors.InvalidResponseSchemaError(res.statusCode)
+          }
+          const matchingContentSchema = matchingResponse.content[contentType]
+
+          if (matchingContentSchema === undefined) {
+            throw new errors.InvalidContentTypeError(contentType)
+          }
+          const bodyIsValid = checkResponseAgainstSchema(responseBody, matchingContentSchema.schema, ajv)
+
+          if (!bodyIsValid) {
+            throw new errors.InvalidResponseFormatError()
+          }
+        } catch (err) {
+          responseBody = createErrorResponse(err.message)
+        }
+      }
+      if (fullResponse) {
+        return {
+          statusCode: res.statusCode,
+          headers: res.headers,
+          body: responseBody
+        }
+      }
+      return responseBody
+    } catch (err) {
+      openTelemetry?.setErrorInSpanClient(span, err)
+      const requestError = new errors.UnexpectedCallFailureError(err.toString())
+      if (err instanceof UndiciError) {
+        requestError.status = err.statusCode
+        requestError.statusCode = err.statusCode
+        requestError.headers = err.headers
+        requestError.body = err.body
+        requestError.data = err.data
+        requestError.socket = err.socket
+      }
+      throw requestError
+    } finally {
+      openTelemetry?.endHTTPSpanClient(span, res)
+    }
+  }
+}
+
+function getRequestBodyContentType (methodMetadata) {
+  let output = null
+  if (!methodMetadata.requestBody) {
+    return 'application/json'
+  }
+  if (methodMetadata.requestBody && methodMetadata.requestBody.content) {
+    if (methodMetadata.requestBody.content['multipart/form-data']) {
+      output = 'multipart/form-data'
+    }
+
+    if (methodMetadata.requestBody.content['application/json']) {
+      output = 'application/json'
+    }
+  }
+  return output
+}
+
+function createErrorResponse (message) {
+  return {
+    statusCode: 500,
+    message
+  }
+}
+
+function sanitizeContentType (contentType) {
+  if (!contentType) {
+    return false
+  }
+  const split = contentType.split(';')
+  return split[0]
+}
+
+function checkResponseAgainstSchema (body, schema, ajv) {
+  const validate = getValidateFunction(schema, ajv)
+  const valid = validate(body)
+  return valid
+}
+
+function getValidateFunction (schema, ajvInstance) {
+  const hash = createHash('md5').update(JSON.stringify(schema)).digest('hex')
+  if (!validateFunctionCache[hash]) {
+    validateFunctionCache[hash] = ajvInstance.compile(schema)
+  }
+  return validateFunctionCache[hash]
+}
+
+function capitalize (str) {
+  return str.charAt(0).toUpperCase() + str.slice(1)
+}
+
+function isArrayQueryParam ({ schema }) {
+  return schema?.type === 'array' || schema?.anyOf?.some(({ type }) => type === 'array')
+}
+
+// TODO: For some unknown reason c8 is not picking up the coverage for this function
+async function graphql (url, log, headers, query, variables, openTelemetry, telemetryContext) {
+  const { span, telemetryHeaders } = openTelemetry?.startHTTPSpanClient(url.toString(), 'POST', telemetryContext) || {
+    span: null,
+    telemetryHeaders: {}
+  }
+
+  headers = {
+    ...headers,
+    ...telemetryHeaders,
+    'content-type': 'application/json; charset=utf-8'
+  }
+
+  let res
+  try {
+    res = await request(url, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({
+        query,
+        variables
+      })
+    })
+
+    const json = await res.body.json()
+
+    if (res.statusCode !== 200) {
+      log.warn({ statusCode: res.statusCode, json }, 'request to client failed')
+      throw new Error('request to client failed')
+    }
+
+    if (json.errors) {
+      log.warn({ errors: json.errors }, 'errors in graphql response')
+      const e = new Error(json.errors.map(e => e.message).join(''))
+      e.errors = json.errors
+      throw e
+    }
+
+    const keys = Object.keys(json.data)
+    if (keys.length !== 1) {
+      return json.data
+    } else {
+      return json.data[keys[0]]
+    }
+  } catch (err) {
+    openTelemetry?.setErrorInSpanClient(span, err)
+    throw err
+  } finally {
+    openTelemetry?.endHTTPSpanClient(span, res)
+  }
+}
+
+function wrapGraphQLClient (url, openTelemetry, logger) {
+  return async function ({ query, variables }) {
+    let headers = this[kHeaders]
+    const telemetryContext = this[kTelemetryContext]
+    if (typeof this[kGetHeaders] === 'function') {
+      headers = { ...headers, ...(await this[kGetHeaders]()) }
+    }
+    const log = this.log || logger
+
+    return graphql(url, log, headers, query, variables, openTelemetry, telemetryContext)
+  }
+}
+
+export function generateOperationId (path, method, methodMeta, all) {
+  let operationId = null
+  // use methodMeta.operationId only if it's present AND it is a valid string that can be
+  // concatenated without converting it
+  // i.e
+  // operationId = "MyOperationId123" is valid
+  // operationId = "/v3/accounts/{id}" is NOT valid and sholuld be converted in "V3AccountsId"
+  if (methodMeta.operationId && methodMeta.operationId.match(/^[a-zA-z0-9]+$/)) {
+    operationId = methodMeta.operationId
+  }
+  if (!operationId) {
+    const pathParams = methodMeta.parameters?.filter(p => p.in === 'path') || []
+    let stringToUpdate = path
+    for (const param of pathParams) {
+      stringToUpdate = stringToUpdate.replace(`{${param.name}}`, capitalize(param.name))
+    }
+    operationId =
+      method.toLowerCase() +
+      stringToUpdate
+        .split(/[/-]+/)
+        .map(token => {
+          const sanitized = token.replace(/[^a-zA-z0-9]/g, '')
+          return capitalize(sanitized)
+        })
+        .join('')
+  } else {
+    let count = 0
+    let candidate = operationId
+    while (all.includes(candidate)) {
+      if (count === 0) {
+        // first try with method name
+        candidate = `${method}${capitalize(operationId)}`
+      } else {
+        candidate = `${method}${capitalize(operationId)}${count}`
+      }
+      count++
+    }
+    operationId = candidate
+  }
+  operationId = camelCase(operationId)
+  all.push(operationId)
+  return operationId
+}
+
+export async function buildOpenAPIClient (options, openTelemetry) {
+  const client = {}
+  let spec
+  let baseUrl
+
+  if (typeof options.getHeaders === 'function') {
+    const getHeaders = options.getHeaders
+    options = { ...options }
+    client[kGetHeaders] = getHeaders
+    options.getHeaders = undefined
+  }
+
+  const { validateResponse, queryParser } = options
+
+  // this is tested, not sure why c8 is not picking it up
+  if (!options.url) {
+    throw new errors.OptionsUrlRequiredError()
+  }
+  if (options.path) {
+    spec = JSON.parse(await fs.readFile(options.path, 'utf8'))
+    baseUrl = options.url.replace(/\/$/, '')
+  } else {
+    const res = await request(options.url)
+    spec = await res.body.json()
+    baseUrl = computeURLWithoutPath(options.url)
+  }
+
+  const kOperationIdMap = Symbol.for('plt.operationIdMap')
+  client[kOperationIdMap] = {}
+  client[kHeaders] = options.headers || {}
+
+  let { fullRequest = true, fullResponse = true, bodyTimeout, headersTimeout, dispatcher } = options
+
+  if (options.throwOnError) {
+    if (!dispatcher) {
+      dispatcher = getGlobalDispatcher()
+    }
+    dispatcher = dispatcher.compose(interceptors.responseError())
+  }
+
+  const generatedOperationIds = []
+  for (const path of Object.keys(spec.paths)) {
+    const pathMeta = spec.paths[path]
+    let commonParameters = []
+    if (pathMeta.parameters) {
+      commonParameters = pathMeta.parameters
+      delete pathMeta.parameters
+    }
+    for (const method of Object.keys(pathMeta)) {
+      const methodMeta = pathMeta[method]
+      if (methodMeta.parameters) {
+        methodMeta.parameters = [...methodMeta.parameters, ...commonParameters]
+      } else {
+        methodMeta.parameters = commonParameters
+      }
+      const operationId = generateOperationId(path, method, methodMeta, generatedOperationIds)
+      const responses = pathMeta[method].responses
+      const successResponses = Object.entries(responses).filter(([s]) => s.startsWith('2'))
+      if (successResponses.length !== 1) {
+        // force fullResponse = true if
+        // - there is more than 1 responses with 2XX code
+        // - there is no responses with 2XX code
+        fullResponse = true
+      }
+
+      client[kOperationIdMap][operationId] = { path, method }
+      client[operationId] = await buildCallFunction(
+        spec,
+        baseUrl,
+        path,
+        method,
+        methodMeta,
+        openTelemetry,
+        fullRequest,
+        fullResponse,
+        validateResponse,
+        queryParser,
+        bodyTimeout,
+        headersTimeout,
+        dispatcher
+      )
+    }
+  }
+  return client
+}
+
+export function hasDuplicatedParameters (methodMeta) {
+  if (!methodMeta.parameters) return false
+  if (methodMeta.parameters.length === 0) {
+    return false
+  }
+  const s = new Set()
+  methodMeta.parameters.forEach(param => {
+    s.add(param.name)
+  })
+  return s.size !== methodMeta.parameters.length
+}
+
+export async function buildGraphQLClient (options, openTelemetry, logger = abstractLogger) {
+  options = options || {}
+  if (!options.url) {
+    throw new Error('options.url is required')
+  }
+
+  return {
+    graphql: wrapGraphQLClient(options.url, openTelemetry, logger),
+    [kHeaders]: options.headers || {}
+  }
+}
+
+export * as errors from './lib/errors.js'

package/index.test-d.ts

@@ -0,0 +1,158 @@
+import { FastifyError } from '@fastify/error'
+import fastify from 'fastify'
+import { expectAssignable, expectError, expectNotAssignable, expectType } from 'tsd'
+import { Agent } from 'undici'
+import {
+  buildOpenAPIClient,
+  errors,
+  type GetHeadersOptions,
+  type StatusCode1xx,
+  type StatusCode2xx,
+  type StatusCode3xx,
+  type StatusCode4xx,
+  type StatusCode5xx
+} from '.'
+import pltClient, { type PlatformaticClientPluginOptions } from './fastify-plugin.js'
+
+const server = await fastify()
+
+expectError<PlatformaticClientPluginOptions>({})
+
+expectError<PlatformaticClientPluginOptions>({
+  fullRequest: true,
+  fullResponse: true,
+  throwOnError: true,
+  url: 'localhost'
+})
+
+expectError<PlatformaticClientPluginOptions>({
+  fullRequest: true,
+  fullResponse: true,
+  throwOnError: true,
+  type: 'WRONG',
+  url: 'localhost'
+})
+
+server.register(pltClient, {
+  fullRequest: true,
+  fullResponse: true,
+  throwOnError: true,
+  type: 'graphql',
+  url: 'localhost'
+})
+
+server.register(pltClient, {
+  fullRequest: false,
+  fullResponse: false,
+  validateResponse: false,
+  throwOnError: false,
+  type: 'openapi',
+  url: 'http://127.0.0.1/path/42',
+  getHeaders: async ({ url }, { sent }, options) => ({
+    foo: 'bar',
+    url,
+    baz: sent.toString(),
+    opt: JSON.stringify(options)
+  }),
+  headers: { foo: 'bar' },
+  name: 'Frassica',
+  path: 'Fracchia',
+  applicationId: 'Fantozzi'
+})
+
+const key = Symbol.for('plt.operationIdMap')
+type MyType = {
+  getFoo: Function
+} & Record<typeof key, { path: string; method: string }>
+
+const dispatcher = new Agent({ allowH2: true, connections: 10 })
+const openTelemetry = {}
+const client = await buildOpenAPIClient<MyType>(
+  {
+    url: 'http://foo.bar',
+    path: 'foobar',
+    fullRequest: true,
+    fullResponse: false,
+    throwOnError: false,
+    validateResponse: false,
+    headers: { foo: 'bar' },
+    bodyTimeout: 900000,
+    headersTimeout: 900000,
+    getHeaders: async (options: GetHeadersOptions) => {
+      const { url } = options
+      return { href: url.href }
+    },
+    queryParser: query => `${query.toString()}[]`,
+    dispatcher
+  },
+  openTelemetry
+)
+
+const isSuccessfulResponse = (status: number): status is StatusCode2xx => status >= 200 && status <= 299
+
+async function _exampleUsageOfStatusCodeType (status: number) {
+  if (isSuccessfulResponse(status)) {
+    expectType<StatusCode2xx>(status)
+  } else {
+    expectError<StatusCode2xx>(status)
+  }
+}
+
+expectNotAssignable<StatusCode1xx>(99)
+expectAssignable<StatusCode1xx>(100)
+expectAssignable<StatusCode1xx>(101)
+expectAssignable<StatusCode1xx>(150)
+expectAssignable<StatusCode1xx>(199)
+expectNotAssignable<StatusCode1xx>(200)
+
+expectNotAssignable<StatusCode2xx>(199)
+expectAssignable<StatusCode2xx>(200)
+expectAssignable<StatusCode2xx>(201)
+expectAssignable<StatusCode2xx>(250)
+expectAssignable<StatusCode2xx>(299)
+expectNotAssignable<StatusCode2xx>(300)
+
+expectNotAssignable<StatusCode3xx>(299)
+expectAssignable<StatusCode3xx>(300)
+expectAssignable<StatusCode3xx>(301)
+expectAssignable<StatusCode3xx>(350)
+expectAssignable<StatusCode3xx>(399)
+expectNotAssignable<StatusCode3xx>(400)
+
+expectNotAssignable<StatusCode4xx>(399)
+expectAssignable<StatusCode4xx>(400)
+expectAssignable<StatusCode4xx>(401)
+expectAssignable<StatusCode4xx>(450)
+expectAssignable<StatusCode4xx>(499)
+expectNotAssignable<StatusCode4xx>(500)
+
+expectNotAssignable<StatusCode5xx>(399)
+expectAssignable<StatusCode5xx>(500)
+expectAssignable<StatusCode5xx>(501)
+expectAssignable<StatusCode5xx>(550)
+expectAssignable<StatusCode5xx>(599)
+expectNotAssignable<StatusCode5xx>(600)
+
+// All params and generic passed
+expectType<MyType>(client)
+expectType<Function>(client.getFoo)
+expectType<{ path: string; method: string }>(client[key])
+
+// Only required params and no generics
+expectType<Promise<unknown>>(
+  buildOpenAPIClient({
+    url: 'https://undici.com/piscina',
+    fullRequest: true,
+    fullResponse: false,
+    throwOnError: false
+  })
+)
+
+expectType<() => FastifyError>(errors.OptionsUrlRequiredError)
+expectType<(_: string) => FastifyError>(errors.FormDataRequiredError)
+expectType<(_: string) => FastifyError>(errors.MissingParamsRequiredError)
+expectType<() => FastifyError>(errors.WrongOptsTypeError)
+expectType<(_: string) => FastifyError>(errors.InvalidResponseSchemaError)
+expectType<(_: string) => FastifyError>(errors.InvalidContentTypeError)
+expectType<() => FastifyError>(errors.InvalidResponseFormatError)
+expectType<(_: string) => FastifyError>(errors.UnexpectedCallFailureError)

package/lib/errors.js

@@ -0,0 +1,33 @@
+import createError from '@fastify/error'
+
+export const ERROR_PREFIX = 'PLT_MASSIMO'
+
+export const OptionsUrlRequiredError = createError(`${ERROR_PREFIX}_OPTIONS_URL_REQUIRED`, 'options.url is required')
+export const FormDataRequiredError = createError(
+  `${ERROR_PREFIX}_FORM_DATA_REQUIRED`,
+  'Operation %s should be called with a undici.FormData as payload'
+)
+export const MissingParamsRequiredError = createError(
+  `${ERROR_PREFIX}_MISSING_PARAMS_REQUIRED`,
+  "Param %s is missing, and it's required"
+)
+export const WrongOptsTypeError = createError(
+  `${ERROR_PREFIX}_WRONG_OPTS_TYPE`,
+  'opts.type must be either "openapi" or "graphql"'
+)
+export const InvalidResponseSchemaError = createError(
+  `${ERROR_PREFIX}_INVALID_RESPONSE_SCHEMA`,
+  'No matching response schema found for status code %s'
+)
+export const InvalidContentTypeError = createError(
+  `${ERROR_PREFIX}_INVALID_CONTENT_TYPE`,
+  'No matching content type schema found for %s'
+)
+export const InvalidResponseFormatError = createError(
+  `${ERROR_PREFIX}_INVALID_RESPONSE_FORMAT`,
+  'Invalid response format'
+)
+export const UnexpectedCallFailureError = createError(
+  `${ERROR_PREFIX}_UNEXPECTED_CALL_FAILURE`,
+  'Unexpected failure calling the client: %s'
+)

package/lib/symbols.js

@@ -0,0 +1,3 @@
+export const kHeaders = Symbol('headers')
+export const kGetHeaders = Symbol('getHeaders')
+export const kTelemetryContext = Symbol('telemetry-context')

package/package.json

@@ -1,12 +1,47 @@
 {
   "name": "massimo",
-  "version": "0.0.1",
+  "version": "0.1.1",
+  "description": "A client for HTTP services.",
   "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/platformatic/massimo.git"
+  },
+  "author": "Platformatic Inc. <oss@platformatic.dev> (https://platformatic.dev)",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/platformatic/massimo/issues"
+  },
+  "homepage": "https://github.com/platformatic/massimo#readme",
+  "devDependencies": {
+    "@fastify/multipart": "^9.0.1",
+    "@platformatic/db": "3.0.0-alpha.6",
+    "@platformatic/foundation": "3.0.0-alpha.6",
+    "@platformatic/service": "3.0.0-alpha.6",
+    "@platformatic/telemetry": "3.0.0-alpha.6",
+    "c8": "^10.0.0",
+    "cleaner-spec-reporter": "^0.5.0",
+    "eslint": "9",
+    "execa": "^9.0.0",
+    "fastify": "^5.0.0",
+    "neostandard": "^0.12.0",
+    "tsd": "^0.32.0",
+    "typescript": "^5.4.2"
   },
-  "keywords": [],
-  "author": "Matteo Collina <hello@matteocollina.com>",
-  "license": "MIT",
-  "description": ""
-}
+  "dependencies": {
+    "@apidevtools/json-schema-ref-parser": "^11.5.4",
+    "@fastify/error": "^4.0.0",
+    "ajv": "^8.12.0",
+    "camelcase": "^6.3.0",
+    "undici": "^7.0.0"
+  },
+  "engines": {
+    "node": ">=22.18.0"
+  },
+  "scripts": {
+    "lint": "eslint",
+    "test": "node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/*.test.js test/**/*.test.js",
+    "posttest": "tsd"
+  }
+}