@treatwell/moleculer-essentials 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1535 @@
+import { S as SCHEMA_REF_NAME, z as zodToOpenAPISchema, o as omitFields, G as GetOpenApiParamsSchema, V as ValidationErrorSchema, F as FileTooBigSchema, a as FileNotExistSchema, U as UnauthorizedErrorSchema, b as ServerErrorSchema, C as COERCE_ARRAY_ATTRIBUTE } from './index-BV1ZqQrU.mjs';
+export { D as DATE_TYPE, E as EMPTY_OBJECT_SCHEMA, O as OBJECTID_TYPE, c as addFieldsToSchema, f as composeSchemas, j as createOpenAPIResponses, e as optionalExceptFields, d as optionalFields, p as pickFields, t as toPartialSchema, i as zodCoerceArray, g as zodDate, h as zodObjectId } from './index-BV1ZqQrU.mjs';
+import { ZodType, ZodObject, ZodOptional, z } from 'zod/v4';
+import { Ajv2019 } from 'ajv/dist/2019.js';
+import { Validators, Errors, Context, ServiceBroker, Service, TracerExporters, MetricReporters } from 'moleculer';
+import addFormats from 'ajv-formats';
+import addKeywords from 'ajv-keywords';
+import { omit, isEqual, merge, isArray, isString, isNaN, isPlainObject, constant, defaultsDeep, isObject, isFunction } from 'lodash';
+import { parseISO } from 'date-fns';
+import { ObjectId } from 'bson';
+import { w as wrapMixin } from './index-DNJWwcZu.mjs';
+export { a as wrapService } from './index-DNJWwcZu.mjs';
+import http, { STATUS_CODES } from 'http';
+import { pino } from 'pino';
+import { hostname } from 'node:os';
+import 'zod';
+
+function getSchemaFromMoleculer(schema) {
+  if (!schema) {
+    return void 0;
+  }
+  if (typeof schema === "object" && !Array.isArray(schema)) {
+    return schema;
+  }
+  if (typeof schema === "function") {
+    const res = schema();
+    if (typeof res === "object" && !Array.isArray(res)) {
+      return res;
+    }
+  }
+  return void 0;
+}
+
+class RefExtractor {
+  refs = /* @__PURE__ */ new Map();
+  meta = {};
+  onError(message, other = {}) {
+    console.log("Error while extracting refs", message, {
+      ...this.meta,
+      ...other
+    });
+    throw new Error(message);
+  }
+  setMeta(meta) {
+    this.meta = meta;
+  }
+  extract(schemaToExtract, initialRef = void 0, skipRoot = false) {
+    const walk = (curr, currentRef, root = false) => {
+      if (curr.$ref) {
+        if (curr.$ref === "#") {
+          if (!currentRef) {
+            throw new Error(
+              "Recursive refs MUST have at least one parent with a SCHEMA_REF_NAME defined"
+            );
+          }
+          return { $ref: currentRef };
+        }
+        return curr;
+      }
+      const schemaRefName = curr[SCHEMA_REF_NAME];
+      if (schemaRefName) {
+        const ref = this.refReplacer(schemaRefName);
+        if (!this.refs.has(schemaRefName)) {
+          this.refs.set(schemaRefName, null);
+        }
+        const newSchema2 = walk(omit(curr, [SCHEMA_REF_NAME, "nullable"]), ref);
+        const registeredSchema = this.refs.get(schemaRefName);
+        if (registeredSchema === null) {
+          this.refs.set(schemaRefName, newSchema2);
+          this.onNewRef(schemaRefName, newSchema2);
+        } else if (!isEqual(newSchema2, registeredSchema)) {
+          this.onError(
+            `Schema ${schemaRefName} is already defined with different content`,
+            { registeredSchema, newSchema: newSchema2 }
+          );
+        }
+        if (skipRoot && root) {
+          return this.refs.get(schemaRefName);
+        }
+        if (curr.nullable) {
+          return {
+            oneOf: [{ $ref: ref }, { type: "null" }]
+          };
+        }
+        return { $ref: ref };
+      }
+      if (["integer", "number", "string", "boolean"].includes(curr.type)) {
+        return curr;
+      }
+      const newSchema = { ...curr };
+      if (newSchema.type === "array" && newSchema.items) {
+        newSchema.items = walk(newSchema.items, currentRef);
+      } else if (newSchema.type === "object") {
+        if (newSchema.properties) {
+          newSchema.properties = { ...newSchema.properties };
+          Object.entries(newSchema.properties).forEach(([key, val]) => {
+            newSchema.properties[key] = walk(val, currentRef);
+          });
+        }
+        if (newSchema.additionalProperties && newSchema.additionalProperties !== true) {
+          newSchema.additionalProperties = walk(
+            newSchema.additionalProperties,
+            currentRef
+          );
+        }
+      }
+      if (Array.isArray(newSchema.oneOf)) {
+        newSchema.oneOf = newSchema.oneOf.map((s) => walk(s, currentRef));
+      }
+      if (Array.isArray(newSchema.allOf)) {
+        newSchema.allOf = newSchema.allOf.map((s) => walk(s, currentRef));
+      }
+      if (Array.isArray(newSchema.anyOf)) {
+        newSchema.anyOf = newSchema.anyOf.map((s) => walk(s, currentRef));
+      }
+      return newSchema;
+    };
+    return walk(schemaToExtract, initialRef, true);
+  }
+}
+
+class OpenAPIExtractor extends RefExtractor {
+  doc;
+  constructor(doc) {
+    super();
+    this.doc = doc;
+  }
+  refReplacer(ref) {
+    return `#/components/schemas/${ref}`;
+  }
+  onNewRef(originalRef, schema) {
+    if (!this.doc.components) {
+      this.doc.components = {};
+    }
+    if (!this.doc.components.schemas) {
+      this.doc.components.schemas = {};
+    }
+    this.doc.components.schemas[originalRef] = schema;
+  }
+}
+
+function generateOpenAPISpec({
+  doc,
+  aliases,
+  services,
+  getSecuritySchemes
+}) {
+  services.forEach((svc) => merge(doc, svc.settings?.openapi));
+  const extractor = new OpenAPIExtractor(doc);
+  if (doc.components?.schemas) {
+    const { schemas } = doc.components;
+    doc.components.schemas = {};
+    for (const [key, val] of Object.entries(schemas)) {
+      doc.components.schemas[key] = extractor.extract(
+        val,
+        `#/components/schemas/${key}`,
+        true
+      );
+    }
+  }
+  for (const alias of aliases) {
+    const url = alias.fullPath.replace(/:(\w+)/g, "{$1}");
+    const p = doc.paths[url] || {};
+    doc.paths[url] = p;
+    const op = createOperationFromAlias(alias, extractor, url);
+    p[alias.methods.toLowerCase()] = op;
+    if (op.responses) {
+      op.responses["401"] = {
+        $ref: "#/components/responses/UnauthorizedError"
+      };
+      op.responses["422"] = { $ref: "#/components/responses/ValidationError" };
+      op.responses["5XX"] = { $ref: "#/components/responses/ServerError" };
+    }
+    const authModes = getSecuritySchemes?.(alias);
+    if (authModes) {
+      op.security = authModes.map((authMode) => ({ [authMode]: [] }));
+    }
+  }
+  if (doc.components?.schemas) {
+    const sortedEntries = Object.entries(doc.components.schemas).sort(
+      (a, b) => a[0] > b[0] ? 1 : -1
+    );
+    doc.components.schemas = Object.fromEntries(sortedEntries);
+  }
+  return doc;
+}
+function createOperationFromAlias(alias, extractor, url) {
+  let parameters;
+  let requestBody;
+  extractor.setMeta({ url, alias });
+  const pathParams = url.match(/{(\w+)}/g) || [];
+  const params = getSchemaFromMoleculer(alias.action.params);
+  if (params instanceof ZodType) {
+    ({ parameters, requestBody } = createOperationFromZodParams(
+      params,
+      pathParams,
+      alias,
+      extractor
+    ));
+  } else {
+    ({ parameters, requestBody } = createOperationFromAjvParams(
+      params,
+      pathParams,
+      alias,
+      extractor
+    ));
+  }
+  const openapi = alias.action.openapi || {};
+  if (openapi.parameters) {
+    if (!parameters) {
+      parameters = [];
+    }
+    for (const param of openapi.parameters) {
+      const newP = param;
+      const idx = parameters.findIndex((p) => p.name === newP.name);
+      if (idx === -1) {
+        parameters.push(newP);
+      } else {
+        parameters[idx] = newP;
+      }
+    }
+  }
+  const responses = {};
+  if (openapi.responses) {
+    for (const [key, val] of Object.entries(openapi.responses)) {
+      responses[key] = val;
+      const content = val.content?.["application/json"];
+      if (content && "zodInstance" in content && typeof content.zodInstance === "function") {
+        content.schema = zodToOpenAPISchema(content.zodInstance(), extractor);
+      } else if (content?.schema) {
+        content.schema = extractor.extract(content.schema);
+      }
+    }
+  }
+  return {
+    requestBody,
+    // Let openapi override requestBody
+    operationId: alias.actionName,
+    ...openapi,
+    responses,
+    parameters
+  };
+}
+function createOperationFromAjvParams(params, pathParams, alias, extractor) {
+  const parameters = [];
+  let requestBody;
+  if (pathParams.length) {
+    parameters.push(
+      ...pathParams.map((p) => {
+        const name = p.slice(1, -1);
+        return {
+          in: "path",
+          name,
+          required: true,
+          schema: extractor.extract(
+            params?.properties?.[name] || { type: "string" }
+          )
+        };
+      })
+    );
+  }
+  if (["get", "delete"].includes(alias.methods.toLowerCase())) {
+    const schemas = [
+      ...params?.allOf || [],
+      ...params?.oneOf || [],
+      ...params?.anyOf || [],
+      ...params && "properties" in params ? [params] : []
+    ];
+    for (const schema of schemas) {
+      parameters.push(
+        ...Object.entries(schema.properties).filter(([key]) => !parameters.find((p) => p.name === key)).map(([key, val]) => ({
+          in: "query",
+          name: key,
+          schema: extractor.extract(val || { type: "string" }),
+          required: schema.required?.includes(key)
+        }))
+      );
+    }
+  } else if (params) {
+    requestBody = {
+      required: true,
+      content: {
+        "application/json": {
+          schema: extractor.extract(
+            omitFields(
+              params,
+              parameters.map((p) => p.name),
+              alias.action.bodySchemaRefName
+            )
+          )
+        }
+      }
+    };
+  }
+  return { requestBody, parameters };
+}
+function createOperationFromZodParams(params, pathParams, alias, extractor) {
+  const parameters = [];
+  let requestBody;
+  if (!(params instanceof ZodObject)) {
+    throw new Error(
+      `Expected params to be an ZodObject in ${alias.actionName}`
+    );
+  }
+  if (pathParams.length) {
+    parameters.push(
+      ...pathParams.map((p) => {
+        const name = p.slice(1, -1);
+        return {
+          in: "path",
+          name,
+          required: true,
+          schema: zodToOpenAPISchema(params.shape[name], extractor)
+        };
+      })
+    );
+  }
+  if (["get", "delete"].includes(alias.methods.toLowerCase())) {
+    parameters.push(
+      ...Object.entries(params.shape).filter(([key]) => !parameters.find((p) => p.name === key)).map(([key, val]) => ({
+        in: "query",
+        name: key,
+        schema: zodToOpenAPISchema(val, extractor),
+        required: !(val instanceof ZodOptional)
+      }))
+    );
+  } else if (params) {
+    let zodBody = params;
+    if (parameters.length > 0) {
+      zodBody = params.omit(
+        Object.fromEntries(parameters.map((p) => [p.name, true]))
+      );
+    }
+    if (alias.action.bodySchemaRefName) {
+      zodBody = zodBody.meta({ id: alias.action.bodySchemaRefName });
+    }
+    requestBody = {
+      required: true,
+      content: {
+        "application/json": { schema: zodToOpenAPISchema(zodBody, extractor) }
+      }
+    };
+  }
+  return { requestBody, parameters };
+}
+
+function OpenAPIMixin(options) {
+  const { swaggerUI, tags, defaultKinds, actionOptions, getSecuritySchemes } = options;
+  return wrapMixin({
+    settings: {
+      openapi: {
+        openapi: "3.0.3",
+        info: {
+          description: "Default Moleculer essentials spec",
+          version: "0.0.0",
+          title: "Sample API"
+        },
+        paths: {},
+        components: {
+          responses: {
+            // Standard moleculer responses
+            ServerError: {
+              description: "Server errors: 500, 501, 400, 404 and etc...",
+              content: { "application/json": { schema: ServerErrorSchema } }
+            },
+            UnauthorizedError: {
+              description: "Need auth",
+              content: {
+                "application/json": { schema: UnauthorizedErrorSchema }
+              }
+            },
+            FileNotExist: {
+              description: "File not exist",
+              content: { "application/json": { schema: FileNotExistSchema } }
+            },
+            FileTooBig: {
+              description: "File too big",
+              content: { "application/json": { schema: FileTooBigSchema } }
+            },
+            ValidationError: {
+              description: "Fields invalid",
+              content: {
+                "application/json": { schema: ValidationErrorSchema }
+              }
+            }
+          },
+          schemas: {
+            OpenAPIModel: {
+              type: "object",
+              properties: {
+                openapi: {
+                  example: "3.0.3",
+                  type: "string",
+                  description: "OpenAPI version"
+                },
+                info: {
+                  type: "object",
+                  properties: { description: { type: "string" } }
+                },
+                tags: { type: "array", items: { type: "string" } }
+              },
+              required: ["openapi"]
+            }
+          }
+        }
+      }
+    },
+    methods: {
+      matchesKind(openAPINames, kind) {
+        if (openAPINames === null) {
+          return false;
+        }
+        if (!kind) {
+          return true;
+        }
+        return (openAPINames || defaultKinds || []).includes(kind);
+      },
+      /**
+       * Generate the OpenAPI schema for the specified kind.
+       */
+      async generateSchema(ctx, kind) {
+        const doc = JSON.parse(JSON.stringify(this.settings.openapi));
+        const [aliases, services] = await Promise.all([
+          ctx.call("api.listAliases", {
+            withActionSchema: true
+          }),
+          ctx.call("$node.services", { onlyAvailable: true, skipInternal: true })
+        ]);
+        return generateOpenAPISpec({
+          doc,
+          getSecuritySchemes,
+          services: services.filter(
+            (svc) => this.matchesKind(svc.settings?.openAPINames, kind)
+          ),
+          aliases: aliases.filter((alias) => this.matchesKind(alias.action.openAPINames, kind)).sort((a, b) => a.actionName > b.actionName ? 1 : -1)
+        });
+      }
+    },
+    actions: {
+      generateDocs: {
+        rest: "GET /openapi.json",
+        openapi: {
+          summary: "OpenAPI schema url",
+          responses: {
+            "200": {
+              description: "",
+              content: {
+                "application/json": {
+                  schema: { $ref: "#/components/schemas/OpenAPIModel" }
+                }
+              }
+            }
+          },
+          tags
+        },
+        ...actionOptions,
+        params: GetOpenApiParamsSchema,
+        handler(ctx) {
+          return this.generateSchema(ctx, ctx.params.kind);
+        }
+      },
+      ui: {
+        rest: "GET /ui",
+        openapi: {
+          summary: "OpenAPI ui",
+          description: "You can provide any schema file in query param",
+          tags
+        },
+        ...actionOptions,
+        handler(ctx) {
+          ctx.meta.$responseType = "text/html";
+          ctx.meta.$responseHeaders = {
+            "Content-Security-Policy": `default-src 'self' unpkg.com; img-src 'self' data:; script-src-elem 'self' 'unsafe-inline' unpkg.com`
+          };
+          const version = swaggerUI?.version || "latest";
+          return `
+      <!DOCTYPE html>
+      <html lang="en">
+        <head>
+           <meta charset="utf-8" />
+           <title>OpenAPI UI</title>
+           <link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist@${version}/swagger-ui.css"/>
+           <link rel="stylesheet" href="https://unpkg.com/normalize.css@8.0.1/normalize.css"/>
+        </head>
+        <body>
+          <div id="swagger-ui">
+            <p>Loading...</p>
+          </div>
+
+          <script src="https://unpkg.com/swagger-ui-dist@${version}/swagger-ui-bundle.js" crossorigin><\/script>
+          <script src="https://unpkg.com/swagger-ui-dist@${version}/swagger-ui-standalone-preset.js" crossorigin><\/script>
+          <script>
+            window.onload = function() {
+            window.ui = SwaggerUIBundle({
+               url: 'openapi.json',
+               dom_id: '#swagger-ui',
+               deepLinking: true,
+               presets: [
+                 SwaggerUIBundle.presets.apis,
+                 SwaggerUIStandalonePreset,
+               ],
+               plugins: [
+                 SwaggerUIBundle.plugins.DownloadUrl
+               ],
+               layout: "StandaloneLayout",
+             });
+            }
+          <\/script>
+        </body>
+      </html>`;
+        }
+      }
+    }
+  });
+}
+
+class LeafTransformerBase {
+  transformMap = /* @__PURE__ */ new WeakMap();
+  findTransformsInternal(schema, currentField) {
+    if (this.isTransformableLeaf(schema)) {
+      currentField.push({ type: "this" });
+      return [currentField];
+    }
+    if (schema.type === "object" && schema.properties) {
+      return Object.entries(schema.properties).flatMap(([key, subSchema]) => {
+        const currentFieldCopy = [...currentField];
+        currentFieldCopy.push({ type: "access", key });
+        return this.findTransformsInternal(
+          subSchema,
+          currentFieldCopy
+        );
+      });
+    }
+    if (schema.type === "array" && schema.items) {
+      currentField.push({ type: "loop" });
+      return this.findTransformsInternal(
+        schema.items,
+        currentField
+      );
+    }
+    if (schema.oneOf || schema.anyOf || schema.allOf) {
+      const arr = schema.oneOf || schema.anyOf || schema.allOf;
+      const subTransforms = arr.flatMap(
+        (subSchema) => this.findTransformsInternal(subSchema, [])
+      );
+      currentField.push({ type: "select", subTransforms });
+      return [currentField];
+    }
+    return [];
+  }
+  findTransforms(schema) {
+    return this.findTransformsInternal(schema, []);
+  }
+}
+
+class CoerceArrayTransformer extends LeafTransformerBase {
+  beforeTransformer = (val) => {
+    if (isArray(val) || val === null) {
+      return val;
+    }
+    return [val];
+  };
+  afterTransformer = (val) => val;
+  isTransformableLeaf = (schema) => schema.type === "array" && schema[COERCE_ARRAY_ATTRIBUTE];
+}
+
+class DateTransformer extends LeafTransformerBase {
+  transformFormats = ["date-time"];
+  beforeTransformer = (val) => {
+    if (val instanceof Date) {
+      return val.toISOString();
+    }
+    return val;
+  };
+  afterTransformer = (val) => {
+    if (!isString(val)) {
+      return val;
+    }
+    const date = parseISO(val);
+    if (isNaN(date.getTime())) {
+      return val;
+    }
+    return date;
+  };
+  isTransformableLeaf(schema) {
+    return schema.type === "string" && this.transformFormats.includes(schema.format);
+  }
+}
+
+class ObjectIdTransformer extends LeafTransformerBase {
+  beforeTransformer = (val) => {
+    if (val?._bsontype?.toLowerCase() === "objectid" && ObjectId.isValid(val)) {
+      return val.toString();
+    }
+    return val;
+  };
+  afterTransformer = (val) => {
+    if (isString(val) && /^[a-f\d]{24}$/i.test(val)) {
+      return new ObjectId(val);
+    }
+    return val;
+  };
+  isTransformableLeaf = (schema) => schema.type === "string" && schema.format === "object-id";
+}
+
+const transformers = [
+  new DateTransformer(),
+  new ObjectIdTransformer(),
+  new CoerceArrayTransformer()
+];
+function applyTransform(parent, dataKey, transformer, transformField, index) {
+  const transformLevel = transformField[index];
+  switch (transformLevel.type) {
+    case "this": {
+      if (!isPlainObject(parent) && !isArray(parent)) {
+        return;
+      }
+      if (parent.hasOwnProperty(dataKey)) {
+        parent[dataKey] = transformer(parent[dataKey]);
+      }
+      break;
+    }
+    case "access":
+      if (!isPlainObject(parent[dataKey])) {
+        return;
+      }
+      applyTransform(
+        parent[dataKey],
+        transformLevel.key,
+        transformer,
+        transformField,
+        index + 1
+      );
+      break;
+    case "select":
+      for (const localTransformField of transformLevel.subTransforms) {
+        applyTransform(parent, dataKey, transformer, localTransformField, 0);
+      }
+      break;
+    case "loop": {
+      if (!isArray(parent[dataKey])) {
+        return;
+      }
+      const cast = parent[dataKey];
+      for (let i = 0; i < cast.length; i += 1) {
+        applyTransform(
+          cast,
+          i,
+          transformer,
+          transformField,
+          index + 1
+        );
+      }
+      break;
+    }
+    default:
+      throw new Error(
+        `Unknown transformLevel type '${transformLevel.type}'`
+      );
+  }
+}
+function applyTransforms(schema, data, transformMap, transformer) {
+  if (transformMap.has(schema)) {
+    const transformFields = transformMap.get(schema);
+    transformFields.forEach((transformField) => {
+      applyTransform({ data }, "data", transformer, transformField, 0);
+    });
+  }
+}
+function applyBeforeTransforms(schema, data) {
+  transformers.forEach((transformer) => {
+    applyTransforms(
+      schema,
+      data,
+      transformer.transformMap,
+      transformer.beforeTransformer
+    );
+  });
+}
+function applyAfterTransforms(schema, data) {
+  transformers.forEach((transformer) => {
+    applyTransforms(
+      schema,
+      data,
+      transformer.transformMap,
+      transformer.afterTransformer
+    );
+  });
+}
+function loadTransforms(schema) {
+  transformers.forEach((transformer) => {
+    if (!transformer.transformMap.has(schema)) {
+      const transforms = transformer.findTransforms(schema);
+      if (transforms.some((t) => t.length === 0)) {
+        const strSchema = JSON.stringify(schema, void 0, 2);
+        throw new Error(`Unsupported transforms found for Schema ${strSchema}`);
+      }
+      transformer.transformMap.set(schema, transforms);
+    }
+  });
+}
+
+class AjvExtractor extends RefExtractor {
+  ajv;
+  constructor(ajv) {
+    super();
+    this.ajv = ajv;
+  }
+  refReplacer(ref) {
+    return `https://schemas.wavy.fr/${ref}`;
+  }
+  onNewRef(originalRef, schema) {
+    this.ajv.addSchema(schema, this.refReplacer(originalRef));
+  }
+}
+
+class AjvValidator extends Validators.Base {
+  modes;
+  defaultMode;
+  // broker is a property of the base class
+  broker;
+  zodValidator;
+  /**
+   * Cache of compiled validation functions.
+   * This is because compiling a schema is quite expensive for Ajv.
+   */
+  compiledFns = /* @__PURE__ */ new WeakMap();
+  constructor(opts, defaultMode, zodValidator) {
+    super();
+    this.defaultMode = defaultMode;
+    this.zodValidator = zodValidator;
+    this.modes = /* @__PURE__ */ new Map();
+    for (const [mode, ajvOpts] of Object.entries(opts)) {
+      const validator = new Ajv2019(ajvOpts);
+      this.modes.set(mode, {
+        validator,
+        extractor: new AjvExtractor(validator)
+      });
+      addFormats(validator);
+      addKeywords(validator);
+      validator.addKeyword({
+        keyword: COERCE_ARRAY_ATTRIBUTE,
+        valid: true
+      });
+      validator.addFormat("object-id", {
+        type: "string",
+        validate: constant(true)
+      });
+    }
+  }
+  validate(params, schema) {
+    if (schema instanceof ZodType) {
+      if (!this.zodValidator) {
+        throw new Error("No validator to handle zod schemas");
+      }
+      return this.zodValidator.validate(params, schema);
+    }
+    return this.compile(schema)(params);
+  }
+  /**
+   * This method compiles a schema into a validation function.
+   *
+   * Compiling a schema is quite expensive, so it will only be done once per schema.
+   */
+  compile(schema, mode = this.defaultMode) {
+    if (this.compiledFns.has(schema)) {
+      return this.compiledFns.get(schema);
+    }
+    const validatorMode = this.modes.get(mode);
+    if (!validatorMode) {
+      throw new Error(`Validator mode ${mode} doesn't exist.`);
+    }
+    try {
+      loadTransforms(schema);
+    } catch (err) {
+      const strSchema = JSON.stringify(schema, void 0, 2);
+      this.broker.logger.error(
+        "Error loading transforms for schema",
+        strSchema
+      );
+      throw err;
+    }
+    const { validator, extractor } = validatorMode;
+    const refSchema = extractor.extract(schema);
+    const fn = (params, ctx) => {
+      if (!ctx?.action?.disableTransforms) {
+        applyBeforeTransforms(schema, params);
+      }
+      const validate = validator.compile(refSchema);
+      const res = validate(params);
+      if (res !== true) {
+        const name = ctx?.action?.name || ctx?.eventName || "unknown";
+        this.logError(name, schema, validate.errors);
+        throw new Errors.ValidationError(
+          `Parameters validation error on ${name}: ${validator.errorsText(
+            validate.errors
+          )}`,
+          "VALIDATION_ERROR",
+          validate.errors || []
+        );
+      }
+      if (!ctx?.action?.disableTransforms) {
+        applyAfterTransforms(schema, params);
+      }
+      return true;
+    };
+    this.compiledFns.set(schema, fn);
+    return fn;
+  }
+  /**
+   * For debugging purposes, log the validation errors.
+   * This is only enabled if the DETAILED_AJV_VALIDATION_ERRORS env var is set to 'yes'.
+   */
+  logError(name, schema, errors) {
+    if (process.env.DETAILED_AJV_VALIDATION_ERRORS !== "yes") {
+      return;
+    }
+    const errorLogMessage = `Validation of parameters given to ${name} against schema ${schema[SCHEMA_REF_NAME]} gave the following errors:
+${(errors || []).map(
+      ({ message, params: errorParameters, instancePath, schemaPath }) => `- ${message} ${JSON.stringify(
+        errorParameters
+      )} @${instancePath} in ${schemaPath}`
+    ).join("\n")}`;
+    this.broker.logger.error(errorLogMessage);
+  }
+  /**
+   * We wrap the localAction and localEvent methods to add validation to the actions and events handlers.
+   * Note that we lazy compile schemas in order to avoid a performance hit on startup.
+   */
+  middleware() {
+    let zodMiddleware = this.zodValidator?.middleware();
+    if (!zodMiddleware) {
+      zodMiddleware = {
+        name: "Validator",
+        localAction() {
+          throw new Error("No validator to handle zod schemas");
+        },
+        localEvent() {
+          throw new Error("No validator to handle zod schemas");
+        }
+      };
+    }
+    return {
+      name: "Validator",
+      localAction: (handler, action) => {
+        const schema = getSchemaFromMoleculer(action.params);
+        if (!schema) {
+          return handler;
+        }
+        if (schema instanceof ZodType) {
+          return zodMiddleware.localAction(
+            handler,
+            action
+          );
+        }
+        const validate = this.compile(schema, action.validatorMode);
+        return async (ctx) => {
+          validate(ctx.params != null ? ctx.params : {}, ctx);
+          return handler(ctx);
+        };
+      },
+      localEvent: (handler, event) => {
+        const schema = getSchemaFromMoleculer(event.params);
+        if (!schema) {
+          return handler;
+        }
+        if (schema instanceof ZodType) {
+          return zodMiddleware.localEvent(
+            handler,
+            event
+          );
+        }
+        const validate = this.compile(schema, event.validatorMode);
+        return async (ctx) => {
+          validate(ctx.params != null ? ctx.params : {}, ctx);
+          return handler(ctx);
+        };
+      }
+    };
+  }
+}
+
+class ZodValidator extends Validators.Base {
+  compile() {
+    throw new Error("compile should not be used, use validate instead");
+  }
+  validate(params, schema, ctx) {
+    const res = schema.safeParse(params);
+    if (res.success) {
+      return res.data;
+    }
+    const name = ctx?.action?.name || ctx?.eventName || "unknown";
+    throw new Errors.ValidationError(
+      `Parameters validation error on ${name}:
+${z.prettifyError(res.error)}`,
+      "VALIDATION_ERROR",
+      res.error.issues
+    );
+  }
+  /**
+   * Override BaseValidator middleware to handle our custom compile function.
+   */
+  middleware() {
+    return {
+      name: "Validator",
+      localAction: (handler, action) => {
+        const schema = getSchemaFromMoleculer(action.params);
+        if (!schema) {
+          return handler;
+        }
+        return async (ctx) => {
+          ctx.params = this.validate(ctx.params, schema, ctx);
+          return handler(ctx);
+        };
+      },
+      localEvent: (handler, event) => {
+        const schema = getSchemaFromMoleculer(event.params);
+        if (!schema) {
+          return handler;
+        }
+        return async (ctx) => {
+          ctx.params = this.validate(ctx.params, schema, ctx);
+          return handler(ctx);
+        };
+      }
+    };
+  }
+}
+
+class ContextFactory extends Context {
+  constructor(broker, endpoint) {
+    super(broker, endpoint);
+    this.setLogger();
+  }
+  startSpan(name, opts) {
+    const span = super.startSpan(name, opts);
+    this.setLogger();
+    return span;
+  }
+  /**
+   * Get a logger for this specific span of the context.
+   */
+  setLogger() {
+    const bindings = {
+      traceID: this.requestID,
+      spanID: this.span ? this.span.id : void 0
+    };
+    if (this.service) {
+      Object.assign(bindings, {
+        svc: this.service.name,
+        ver: this.service.version
+      });
+    }
+    this.logger = this.broker.getLogger(
+      this.service ? this.service.fullName : "context",
+      bindings
+    );
+  }
+}
+
+const NOOP_CACHE = {
+  get: () => void 0,
+  set: () => void 0
+};
+class CustomServiceBroker extends ServiceBroker {
+  /**
+   * By replacing the cache property of the loggerFactory, we can disable the cache.
+   * This is because caching loggers can lead to OOM because of
+   * the large number of child loggers created (one per span).
+   */
+  getLogger(module, props) {
+    this.loggerFactory.cache = NOOP_CACHE;
+    return super.getLogger(module, props);
+  }
+}
+
+function lockAllParams(schema) {
+  if (schema?.mixins) {
+    for (const mixin of schema.mixins) {
+      lockAllParams(mixin);
+    }
+  }
+  if (schema?.actions) {
+    for (const action of Object.values(schema.actions)) {
+      if (action && typeof action === "object" && "params" in action && typeof action.params === "object") {
+        const rawParams = action.params;
+        action.params = () => rawParams;
+      }
+    }
+  }
+  if (schema?.events) {
+    for (const event of Object.values(schema.events)) {
+      if (event && typeof event === "object" && "params" in event && typeof event.params === "object") {
+        const rawParams = event.params;
+        event.params = () => rawParams;
+      }
+    }
+  }
+}
+class ServiceFactory extends Service {
+  constructor(broker, schema) {
+    lockAllParams(schema);
+    super(broker, schema);
+  }
+}
+
+function createServiceBroker(opts = {}) {
+  return new CustomServiceBroker({
+    logger: process.env.NODE_ENV === "test" ? false : void 0,
+    // TODO Add default logger
+    validator: new AjvValidator(
+      {
+        default: {
+          useDefaults: true,
+          coerceTypes: true,
+          allErrors: true,
+          removeAdditional: false
+        }
+      },
+      "default",
+      new ZodValidator()
+    ),
+    ServiceFactory,
+    ContextFactory,
+    internalServices: false,
+    ...opts
+  });
+}
+
+function isServiceSelected(metadata, selector) {
+  const s = {
+    ...selector,
+    matchExpressions: selector.matchExpressions?.slice() || []
+  };
+  if (s.matchLabels) {
+    s.matchExpressions.push(
+      ...Object.entries(s.matchLabels).map(([key, value]) => ({
+        key,
+        operator: "in",
+        values: [value]
+      }))
+    );
+  }
+  return s.matchExpressions.every((rule) => isServiceMatchRule(metadata, rule));
+}
+function isServiceMatchRule(metadata, rule) {
+  const meta = metadata || {};
+  switch (rule.operator) {
+    case "in":
+      return rule.values.includes(meta[rule.key]?.toString());
+    case "notin":
+      return !rule.values.includes(meta[rule.key]?.toString());
+    case "exists":
+      return rule.key in meta;
+    case "doesnotexists":
+      return !(rule.key in meta);
+    default:
+      throw new Error("Unknown operator");
+  }
+}
+function getMetadataFromService(svc) {
+  const res = {
+    name: svc.name || "unknown"
+  };
+  defaultsDeep(res, svc.metadata);
+  svc.mixins?.forEach((mixin) => {
+    defaultsDeep(res, mixin.metadata);
+    mixin.mixins?.forEach((m) => {
+      defaultsDeep(res, getMetadataFromService(m));
+    });
+  });
+  return res;
+}
+
+const DEFAULT_OPTIONS = {
+  port: 3001,
+  startDebounce: 500,
+  readiness: { path: "/ready" },
+  liveness: { path: "/live" }
+};
+function HealthCheckMiddleware(_opts) {
+  const opts = defaultsDeep(_opts, DEFAULT_OPTIONS);
+  let state = "down";
+  let server;
+  function handler(req, res) {
+    if (req.url === opts.readiness.path || req.url === opts.liveness.path) {
+      const resHeader = {
+        "Content-Type": "application/json; charset=utf-8"
+      };
+      const content = {
+        state,
+        uptime: process.uptime(),
+        timestamp: Date.now()
+      };
+      if (req.url === opts.readiness.path) {
+        res.writeHead(state === "up" ? 200 : 503, resHeader);
+      } else {
+        res.writeHead(state !== "down" ? 200 : 503, resHeader);
+      }
+      res.end(JSON.stringify(content, null, 2));
+    } else {
+      res.writeHead(404, STATUS_CODES[404], {});
+      res.end();
+    }
+  }
+  return {
+    created(broker) {
+      state = "starting";
+      server = http.createServer(handler);
+      server.listen(opts.port, (err) => {
+        if (err) {
+          broker.logger.error("Unable to start health-check server", err);
+          return;
+        }
+        broker.logger.info(
+          `Health-check server listening on port ${opts.port}`,
+          { readiness: opts.readiness.path, liveness: opts.liveness.path }
+        );
+      });
+    },
+    // After broker started
+    started() {
+      const timeout = setTimeout(() => {
+        state = "up";
+      }, opts.startDebounce);
+      timeout.unref();
+    },
+    // Before broker stopping
+    stopping() {
+      state = "stopping";
+    },
+    // After broker stopped
+    stopped() {
+      state = "down";
+      server.close();
+    }
+  };
+}
+
+const FILTER_SERVICE_LOGS_REGEX = /('[^']*' service is registered\.)|(Service '[^']*' started\.)|('[^']*' finished starting\.)/;
+let transport;
+if (process.env.NODE_ENV !== "production") {
+  transport = {
+    target: "./pino-pretty-transport.cjs",
+    options: {
+      colorize: true,
+      singleLine: true,
+      ignore: [
+        "hostname",
+        // Hide req and res in logs as it will be included in the pretty message
+        // or is not useful in development
+        "req",
+        "res",
+        "responseTime",
+        "span\\.id"
+      ].join(",")
+    }
+  };
+}
+const logger = pino({
+  base: {
+    hostname: hostname(),
+    // Need to set this to allow logs in context of traces
+    // Note that this will not work with dotenv loaded environment variables.
+    "service.name": process.env.NEWRELIC_APP_NAME
+  },
+  transport,
+  hooks: {
+    /**
+     * This function allow logs like `logger.info('str 1', {a: 1}, 'str 2', ...)` to
+     * be formatted correctly (every string are concatenated into one and objects are merged in the log).
+     */
+    logMethod(args, method) {
+      const mergingObject = {};
+      let msg = "";
+      for (const arg of args) {
+        if (arg instanceof Error) {
+          mergingObject.err = arg;
+        } else if (typeof arg === "string") {
+          msg += (msg ? " " : "") + arg;
+        } else if (arg && typeof arg.msg === "string") {
+          msg += (msg ? " " : "") + arg.msg;
+          Object.assign(mergingObject, arg);
+        } else {
+          Object.assign(mergingObject, arg);
+        }
+      }
+      if (process.env.FILTER_SERVICE_LOGS === "yes" && FILTER_SERVICE_LOGS_REGEX.test(msg)) {
+        return void 0;
+      }
+      mergingObject.msg = msg;
+      return method.apply(this, [mergingObject]);
+    }
+  },
+  redact: {
+    paths: [
+      // Request headers
+      "req.headers.authorization",
+      'req.headers["device-useragent"]',
+      "req.headers.connection",
+      'req.headers["content-type"]',
+      'req.headers["accept"]',
+      'req.headers["keep-alive"]',
+      'req.headers["dnt"]',
+      'req.headers["accept-encoding"]',
+      'req.headers["accept-language"]',
+      'req.headers["sec-fetch-site"]',
+      'req.headers["sec-fetch-mode"]',
+      'req.headers["sec-fetch-dest"]',
+      'req.headers["sec-fetch-user"]',
+      'req.headers["sec-ch-ua"]',
+      'req.headers["sec-ch-ua-mobile"]',
+      'req.headers["upgrade-insecure-requests"]',
+      'req.headers["if-none-match"]',
+      'req.headers["cookie"]',
+      "req.headers.referer",
+      // Response headers
+      "res.headers.allow",
+      "res.headers.vary",
+      'res.headers["x-powered-by"]',
+      'res.headers["access-control-allow-origin"]',
+      'res.headers["content-type"]',
+      'res.headers["content-encoding"]'
+    ],
+    remove: true
+  }
+});
+const createLogger = (bindings) => logger.child(bindings);
+function createLoggerConfig() {
+  return {
+    type: "Pino",
+    options: {
+      createLogger: (level, bindings) => createLogger({
+        label: bindings.mod,
+        "trace.id": bindings.traceID,
+        "span.id": bindings.spanID
+      })
+    }
+  };
+}
+const defaultLogger = createLogger({ label: "default" });
+
+function flattenTags(obj, convertToString = false, path = "") {
+  if (!obj) return null;
+  return Object.keys(obj).reduce((res, k) => {
+    const o = obj[k];
+    const pp = (path ? `${path}.` : "") + k;
+    if (isObject(o)) {
+      if ("toHexString" in o) {
+        res[pp] = o.toString();
+      } else {
+        Object.assign(res, flattenTags(o, convertToString, pp));
+      }
+    } else if (o !== void 0 && o !== null) {
+      res[pp] = convertToString ? String(o) : o;
+    }
+    return res;
+  }, {});
+}
+
+class NewrelicTraceExporter extends TracerExporters.Base {
+  queue;
+  timer = null;
+  defaultTags = {};
+  constructor(opts) {
+    super(opts);
+    this.opts = defaultsDeep(this.opts, {
+      baseURL: process.env.NEW_RELIC_TRACE_API_URL || "https://trace-api.newrelic.com",
+      batchSize: 1e3,
+      insertKey: "",
+      interval: 5,
+      defaultTags: null
+    });
+    this.queue = [];
+  }
+  /**
+   * Initialize Trace Exporter.
+   */
+  init(tracer) {
+    super.init(tracer);
+    if (this.opts.interval > 0) {
+      this.timer = setInterval(() => this.flush(), this.opts.interval * 1e3);
+      this.timer.unref();
+    }
+    this.defaultTags = isFunction(this.opts.defaultTags) ? this.opts.defaultTags.call(this, tracer) : this.opts.defaultTags;
+    if (this.defaultTags) {
+      this.defaultTags = flattenTags(this.defaultTags, true);
+    }
+  }
+  /**
+   * Stop Trace exporter
+   */
+  async stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  /**
+   * Span is finished.
+   */
+  spanFinished(span) {
+    this.queue.push(span);
+    if (this.queue.length >= this.opts.batchSize) {
+      this.flush();
+    }
+  }
+  /**
+   * Flush tracing data to NewRelic Zipkin api endpoint
+   */
+  async flush() {
+    if (!this.queue.length) {
+      return;
+    }
+    const data = this.generateTracingData();
+    this.queue.length = 0;
+    try {
+      const res = await fetch(`${this.opts.baseURL}/trace/v1`, {
+        method: "post",
+        body: JSON.stringify(data),
+        headers: {
+          "Content-Type": "application/json",
+          "Api-Key": this.opts.insertKey,
+          "Data-Format": "newrelic",
+          "Data-Format-Version": "1"
+        }
+      });
+      if (res.status >= 400) {
+        this.logger.warn(
+          `Unable to upload tracing spans to NewRelic. Status: ${res.status} ${res.statusText}`
+        );
+      } else {
+        this.logger.debug(
+          `Tracing spans (${data.length} spans) uploaded to NewRelic. Status: ${res.statusText}`
+        );
+      }
+    } catch (err) {
+      this.logger.warn(
+        `Unable to upload tracing spans to NewRelic. Error:${err.message}`,
+        err
+      );
+    }
+  }
+  /**
+   * Generate tracing data for NewRelic
+   */
+  generateTracingData() {
+    return [
+      {
+        common: { attributes: this.defaultTags || {} },
+        spans: this.queue.map((span) => this.makePayload(span))
+      }
+    ];
+  }
+  /**
+   * Create NewRelic v1 payload
+   */
+  makePayload(span) {
+    return {
+      // Trace & span IDs
+      "trace.id": span.traceID,
+      id: span.id,
+      timestamp: span.startTime,
+      attributes: {
+        "duration.ms": span.duration,
+        name: span.name,
+        "parent.id": span.parentID,
+        // @ts-expect-error fullName isn't declared on span yet
+        "service.name": span.service?.fullName || null,
+        ...flattenTags(span.tags, true),
+        ...flattenTags(this.errorToObject(span.error), true, "error") || {}
+      }
+    };
+  }
+}
+
+class NewrelicMetricsReporter extends MetricReporters.Base {
+  // Those fields are not declared on the Base class.
+  registry;
+  logger;
+  timer = null;
+  defaultTags = {};
+  constructor(opts) {
+    super(opts);
+    this.opts = defaultsDeep(this.opts, {
+      baseURL: process.env.NEW_RELIC_METRICS_API_URL || "https://metric-api.newrelic.com",
+      insertKey: "",
+      interval: 10
+    });
+  }
+  /**
+   * Initialize Trace Exporter.
+   */
+  init(registry) {
+    super.init(registry);
+    if (this.opts.interval > 0) {
+      this.timer = setInterval(() => this.flush(), this.opts.interval * 1e3);
+      this.timer.unref();
+    }
+    const defaultTags = isFunction(this.opts.defaultTags) ? this.opts.defaultTags.call(this, registry) : this.opts.defaultTags;
+    if (defaultTags) {
+      this.defaultTags = flattenTags(defaultTags, true);
+    }
+  }
+  /**
+   * Stop Trace exporter
+   */
+  async stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  /**
+   * Flush tracing data to NewRelic Zipkin api endpoint
+   */
+  async flush() {
+    const data = this.generateMetricsPayload();
+    if (!this.opts.insertKey) {
+      this.logger.warn(
+        `Unable to upload metrics to NewRelic. No insertKey provided.`
+      );
+      return;
+    }
+    try {
+      const res = await fetch(`${this.opts.baseURL}/metric/v1`, {
+        method: "post",
+        body: JSON.stringify(data),
+        headers: {
+          "Content-Type": "application/json",
+          "Api-Key": this.opts.insertKey
+        }
+      });
+      if (res.status >= 400) {
+        this.logger.warn(
+          `Unable to upload metrics to NewRelic. Status: ${res.status} ${res.statusText}`
+        );
+      } else {
+        this.logger.debug(
+          `Tracing metrics uploaded to NewRelic. Status: ${res.statusText}`
+        );
+      }
+    } catch (err) {
+      this.logger.warn(
+        `Unable to upload metrics to NewRelic. Error:${err.message}`,
+        err
+      );
+    }
+  }
+  /**
+   * Generate metrics data for NewRelic
+   */
+  generateMetricsPayload() {
+    const metrics = [];
+    this.registry.store.forEach((metric) => {
+      if (!this.matchMetricName(metric.name)) {
+        return;
+      }
+      if (metric.name.startsWith("os.datetime")) {
+        return;
+      }
+      const snapshot = metric.snapshot();
+      if (!snapshot.length) {
+        return;
+      }
+      switch (metric.type) {
+        case "counter":
+        case "gauge":
+          snapshot.forEach((item) => {
+            const { value, timestamp, labels } = item;
+            metrics.push({
+              name: metric.name,
+              attributes: labels,
+              type: "gauge",
+              timestamp,
+              value
+            });
+          });
+          break;
+        case "histogram":
+          snapshot.forEach((item) => {
+            const {
+              timestamp,
+              labels,
+              count,
+              min,
+              max,
+              sum,
+              buckets,
+              quantiles
+            } = item;
+            metrics.push({
+              name: metric.name,
+              type: "summary",
+              attributes: labels,
+              timestamp,
+              value: { count, sum, min: min || 0, max: max || 0 },
+              "interval.ms": this.opts.interval * 1e3
+            });
+            if (buckets) {
+              Object.entries(buckets).forEach(([key, val]) => {
+                metrics.push({
+                  name: `${metric.name}.${key}`,
+                  type: "gauge",
+                  attributes: labels,
+                  timestamp,
+                  value: val
+                });
+              });
+            }
+            if (quantiles) {
+              Object.entries(quantiles).forEach(([key, val]) => {
+                metrics.push({
+                  name: `${metric.name}.q.${key}`,
+                  type: "gauge",
+                  attributes: labels,
+                  timestamp,
+                  value: val
+                });
+              });
+            }
+          });
+          break;
+      }
+    });
+    return [
+      {
+        common: { attributes: this.defaultTags || {} },
+        metrics
+      }
+    ];
+  }
+}
+
+export { AjvExtractor, AjvValidator, COERCE_ARRAY_ATTRIBUTE, ContextFactory, HealthCheckMiddleware, NewrelicMetricsReporter, NewrelicTraceExporter, OpenAPIExtractor, OpenAPIMixin, RefExtractor, SCHEMA_REF_NAME, ServiceFactory, ZodValidator, createLogger, createLoggerConfig, createServiceBroker, defaultLogger, getMetadataFromService, isServiceSelected, omitFields, wrapMixin, zodToOpenAPISchema };