@cosmneo/onion-lasagna 0.3.0 → 0.4.0

package/dist/index.cjs

@@ -56,7 +56,22 @@ __export(src_exports, {
   UnauthorizedError: () => UnauthorizedError,
   UnprocessableError: () => UnprocessableError,
   UseCaseError: () => UseCaseError,
+  collectFields: () => collectFields,
+  defineGraphQLSchema: () => defineGraphQLSchema,
+  defineMutation: () => defineMutation,
+  defineQuery: () => defineQuery,
+  defineSubscription: () => defineSubscription,
   fieldChanged: () => fieldChanged,
+  generateFieldId: () => generateFieldId,
+  generateGraphQLSDL: () => generateGraphQLSDL,
+  getGraphQLErrorCode: () => getGraphQLErrorCode,
+  graphqlRoutes: () => graphqlRoutes,
+  isFieldDefinition: () => isFieldDefinition,
+  isSchemaDefinition: () => isSchemaDefinition,
+  isSimpleGraphQLHandlerConfig: () => isSimpleGraphQLHandlerConfig,
+  mapErrorToGraphQLError: () => mapErrorToGraphQLError,
+  mergeGraphQLSchemas: () => mergeGraphQLSchemas,
+  shouldMaskGraphQLError: () => shouldMaskGraphQLError,
   wrapError: () => wrapError,
   wrapErrorAsync: () => wrapErrorAsync,
   wrapErrorUnless: () => wrapErrorUnless,
@@ -1719,6 +1734,648 @@ var InvalidRequestError = class _InvalidRequestError extends CodedError {
   }
 };
 
+// src/presentation/graphql/field/define-field.ts
+function createFieldDefinition(operation, input) {
+  const definition = {
+    operation,
+    input: input.input ?? void 0,
+    output: input.output ?? void 0,
+    context: input.context ?? void 0,
+    docs: {
+      summary: input.docs?.summary,
+      description: input.docs?.description,
+      tags: input.docs?.tags,
+      deprecated: input.docs?.deprecated ?? false,
+      deprecationReason: input.docs?.deprecationReason
+    },
+    _isGraphQLField: true,
+    _types: void 0
+  };
+  return Object.freeze(definition);
+}
+function defineQuery(config = {}) {
+  return createFieldDefinition("query", config);
+}
+function defineMutation(config = {}) {
+  return createFieldDefinition("mutation", config);
+}
+function defineSubscription(config = {}) {
+  return createFieldDefinition("subscription", config);
+}
+
+// src/presentation/graphql/field/types/schema-definition.type.ts
+function isFieldDefinition(value) {
+  return typeof value === "object" && value !== null && "_isGraphQLField" in value && value._isGraphQLField === true;
+}
+function isSchemaDefinition(value) {
+  return typeof value === "object" && value !== null && "_isGraphQLSchema" in value && value._isGraphQLSchema === true;
+}
+function collectFields(config, basePath = "") {
+  const fields = [];
+  for (const [key, value] of Object.entries(config)) {
+    const fullKey = basePath ? `${basePath}.${key}` : key;
+    if (isFieldDefinition(value)) {
+      fields.push({ key: fullKey, field: value });
+    } else if (isSchemaDefinition(value)) {
+      fields.push(...collectFields(value.fields, fullKey));
+    } else if (typeof value === "object" && value !== null) {
+      fields.push(...collectFields(value, fullKey));
+    }
+  }
+  return fields;
+}
+
+// src/presentation/graphql/field/define-schema.ts
+function defineGraphQLSchema(fields, options) {
+  const defaults = options?.defaults;
+  const processedFields = defaults?.context || defaults?.tags ? applySchemaDefaults(fields, defaults) : fields;
+  const definition = {
+    fields: processedFields,
+    defaults,
+    _isGraphQLSchema: true
+  };
+  return deepFreeze(definition);
+}
+function applySchemaDefaults(config, defaults) {
+  const result = {};
+  for (const [key, value] of Object.entries(config)) {
+    if (isFieldDefinition(value)) {
+      result[key] = applyDefaultsToField(value, defaults);
+    } else if (isSchemaDefinition(value)) {
+      result[key] = {
+        ...value,
+        fields: applySchemaDefaults(value.fields, defaults)
+      };
+    } else if (typeof value === "object" && value !== null) {
+      result[key] = applySchemaDefaults(value, defaults);
+    }
+  }
+  return result;
+}
+function applyDefaultsToField(field, defaults) {
+  const needsContext = defaults.context && !field.context;
+  const needsTags = defaults.tags && defaults.tags.length > 0;
+  if (!needsContext && !needsTags) return field;
+  return Object.freeze({
+    ...field,
+    context: field.context ?? defaults.context ?? void 0,
+    docs: {
+      ...field.docs,
+      tags: mergeTags(defaults.tags, field.docs.tags)
+    }
+  });
+}
+function mergeTags(schemaTags, fieldTags) {
+  if (!schemaTags || schemaTags.length === 0) return fieldTags;
+  if (!fieldTags || fieldTags.length === 0) return schemaTags;
+  const merged = [...schemaTags];
+  for (const tag of fieldTags) {
+    if (!merged.includes(tag)) {
+      merged.push(tag);
+    }
+  }
+  return merged;
+}
+function deepFreeze(obj) {
+  const propNames = Object.getOwnPropertyNames(obj);
+  for (const name of propNames) {
+    const value = obj[name];
+    if (value && typeof value === "object" && !Object.isFrozen(value)) {
+      deepFreeze(value);
+    }
+  }
+  return Object.freeze(obj);
+}
+function extractFields(input) {
+  return isSchemaDefinition(input) ? input.fields : input;
+}
+function isSubGroup(value) {
+  return typeof value === "object" && value !== null && !isFieldDefinition(value) && !isSchemaDefinition(value);
+}
+function deepMergeConfigs(a, b) {
+  const result = { ...a };
+  for (const key of Object.keys(b)) {
+    const aVal = result[key];
+    const bVal = b[key];
+    if (isSubGroup(aVal) && isSubGroup(bVal)) {
+      result[key] = deepMergeConfigs(aVal, bVal);
+    } else {
+      result[key] = bVal;
+    }
+  }
+  return result;
+}
+function mergeGraphQLSchemas(...schemas) {
+  const merged = schemas.map(extractFields).reduce(deepMergeConfigs);
+  return defineGraphQLSchema(merged);
+}
+
+// src/presentation/graphql/field/utils.ts
+function generateFieldId(key) {
+  return key.split(".").map(
+    (segment, index) => index === 0 ? segment : segment.charAt(0).toUpperCase() + segment.slice(1)
+  ).join("");
+}
+
+// src/presentation/http/shared/error-mapping.ts
+function isErrorType(error, typeName) {
+  if (!error || typeof error !== "object") return false;
+  const constructor = Object.prototype.hasOwnProperty.call(error, "constructor") ? error.constructor : Object.getPrototypeOf(error)?.constructor;
+  if (!constructor) return false;
+  const name = constructor.name;
+  return name === typeName || name === `_${typeName}`;
+}
+function hasValidationErrors(error) {
+  if (!error || typeof error !== "object") return false;
+  return "validationErrors" in error && Array.isArray(error.validationErrors);
+}
+
+// src/presentation/graphql/shared/error-mapping.ts
+var MASKED_ERROR = {
+  message: "An unexpected error occurred",
+  extensions: { code: "INTERNAL_ERROR" }
+};
+var INTERNAL_ERROR_TYPES = [
+  "DomainError",
+  "InfraError",
+  "ControllerError",
+  "NetworkError",
+  "PersistenceError",
+  "ExternalServiceError",
+  "InvariantViolationError"
+];
+function getGraphQLErrorCode(error) {
+  if (error instanceof ObjectValidationError) return "VALIDATION_ERROR";
+  if (error instanceof UnauthorizedError) return "FORBIDDEN";
+  if (error instanceof ForbiddenError) return "FORBIDDEN";
+  if (error instanceof AccessDeniedError) return "FORBIDDEN";
+  if (error instanceof NotFoundError) return "NOT_FOUND";
+  if (error instanceof ConflictError) return "CONFLICT";
+  if (error instanceof UnprocessableError) return "UNPROCESSABLE";
+  if (error instanceof UseCaseError) return "BAD_REQUEST";
+  if (isErrorType(error, "ObjectValidationError")) return "VALIDATION_ERROR";
+  if (isErrorType(error, "UnauthorizedError")) return "FORBIDDEN";
+  if (isErrorType(error, "ForbiddenError")) return "FORBIDDEN";
+  if (isErrorType(error, "AccessDeniedError")) return "FORBIDDEN";
+  if (isErrorType(error, "NotFoundError")) return "NOT_FOUND";
+  if (isErrorType(error, "ConflictError")) return "CONFLICT";
+  if (isErrorType(error, "UnprocessableError")) return "UNPROCESSABLE";
+  if (isErrorType(error, "UseCaseError")) return "BAD_REQUEST";
+  return "INTERNAL_ERROR";
+}
+function shouldMaskGraphQLError(error) {
+  if (error instanceof DomainError || error instanceof InfraError) {
+    return true;
+  }
+  for (const errorType of INTERNAL_ERROR_TYPES) {
+    if (isErrorType(error, errorType)) {
+      return true;
+    }
+  }
+  return false;
+}
+function mapErrorToGraphQLError(error) {
+  if (shouldMaskGraphQLError(error)) {
+    return MASKED_ERROR;
+  }
+  const code = getGraphQLErrorCode(error);
+  if (error instanceof ObjectValidationError) {
+    return buildValidationError(error.message, code, error.code, error.validationErrors);
+  }
+  if (isErrorType(error, "ObjectValidationError") && hasValidationErrors(error)) {
+    return buildValidationError(error.message, code, error.code, error.validationErrors);
+  }
+  if (error instanceof CodedError) {
+    return {
+      message: error.message,
+      extensions: { code, originalCode: error.code }
+    };
+  }
+  if (isErrorType(error, "CodedError")) {
+    return {
+      message: error.message,
+      extensions: { code, originalCode: error.code }
+    };
+  }
+  if (error && typeof error === "object" && "message" in error && "code" in error && typeof error.message === "string" && typeof error.code === "string") {
+    return {
+      message: error.message,
+      extensions: { code, originalCode: error.code }
+    };
+  }
+  return MASKED_ERROR;
+}
+function buildValidationError(message, code, originalCode, validationErrors) {
+  return {
+    message,
+    extensions: {
+      code,
+      originalCode,
+      validationErrors: validationErrors.map(
+        (e) => ({
+          field: e.field,
+          message: e.message
+        })
+      )
+    }
+  };
+}
+
+// src/presentation/graphql/server/types.ts
+function isSimpleGraphQLHandlerConfig(config) {
+  return "handler" in config && typeof config.handler === "function";
+}
+
+// src/presentation/graphql/server/create-graphql-routes.ts
+function createGraphQLRoutesInternal(schema, handlers, options) {
+  const config = isSchemaDefinition(schema) ? schema.fields : schema;
+  const collectedFields = collectFields(config);
+  const result = [];
+  const resolvedOptions = {
+    ...options,
+    validateInput: options?.validateInput ?? true,
+    validateOutput: options?.validateOutput ?? true,
+    allowPartial: options?.allowPartial ?? false
+  };
+  for (const { key, field } of collectedFields) {
+    const handlerConfig = handlers[key];
+    if (!handlerConfig) {
+      if (resolvedOptions.allowPartial) {
+        continue;
+      }
+      throw new Error(
+        `Missing handler for field "${key}". All fields must have a handler configuration.`
+      );
+    }
+    result.push(createFieldHandler(key, field, handlerConfig, resolvedOptions));
+  }
+  return result;
+}
+function createFieldHandler(key, field, config, options) {
+  const middleware = config.middleware ?? [];
+  const globalMiddleware = options?.middleware ?? [];
+  const allMiddleware = [...globalMiddleware, ...middleware];
+  const shouldValidateInput = options.validateInput ?? true;
+  const shouldValidateOutput = options.validateOutput ?? true;
+  return {
+    key,
+    operation: field.operation,
+    metadata: {
+      fieldId: generateFieldId(key),
+      description: field.docs.description,
+      tags: field.docs.tags,
+      deprecated: field.docs.deprecated,
+      deprecationReason: field.docs.deprecationReason
+    },
+    handler: async (rawArgs, rawContext) => {
+      const context = options?.createContext ? options.createContext(rawContext) : rawContext ?? { requestId: generateRequestId() };
+      let validatedContext = context;
+      if (field.context) {
+        const contextResult = validateContextData(field, context);
+        if (!contextResult.success) {
+          throw new UnauthorizedError({
+            message: "Authentication required"
+          });
+        }
+        validatedContext = contextResult.data;
+      }
+      let validatedInput = rawArgs;
+      if (shouldValidateInput && field.input) {
+        const inputResult = validateInputData(field, rawArgs);
+        if (!inputResult.success) {
+          const errors = inputResult.errors ?? [];
+          throw new ObjectValidationError({
+            message: "Input validation failed",
+            validationErrors: errors.map((e) => ({
+              field: e.path.join("."),
+              message: e.message
+            }))
+          });
+        }
+        validatedInput = inputResult.data;
+      }
+      const validatedArgs = {
+        input: validatedInput,
+        raw: rawArgs
+      };
+      const executePipeline = async () => {
+        if (isSimpleGraphQLHandlerConfig(config)) {
+          return config.handler(
+            validatedArgs,
+            validatedContext
+          );
+        } else {
+          const { argsMapper, useCase, responseMapper } = config;
+          const input = argsMapper(
+            validatedArgs,
+            validatedContext
+          );
+          const output = await useCase.execute(input);
+          return responseMapper(output);
+        }
+      };
+      let result;
+      if (allMiddleware.length === 0) {
+        result = await executePipeline();
+      } else {
+        let index = 0;
+        let called = false;
+        const next = async () => {
+          if (index >= allMiddleware.length) {
+            if (called) throw new Error("next() called after pipeline already executed");
+            called = true;
+            return executePipeline();
+          }
+          const currentIndex = index++;
+          const mw = allMiddleware[currentIndex];
+          return mw(rawArgs, context, next);
+        };
+        result = await next();
+      }
+      if (shouldValidateOutput && field.output) {
+        const outputResult = validateOutputData(field, result);
+        if (!outputResult.success) {
+          const details = outputResult.errors?.map((e) => `${e.path.join(".")}: ${e.message}`).join("; ");
+          throw new ObjectValidationError({
+            message: `Output validation failed for field "${key}": ${details}`,
+            validationErrors: (outputResult.errors ?? []).map((e) => ({
+              field: e.path.join("."),
+              message: e.message
+            }))
+          });
+        }
+      }
+      return result;
+    }
+  };
+}
+function validateInputData(field, args) {
+  const schema = field.input;
+  if (!schema) return { success: true, data: args };
+  const result = schema.validate(args);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  const errors = result.issues.map((issue) => ({
+    ...issue,
+    path: ["input", ...issue.path]
+  }));
+  return { success: false, errors };
+}
+function validateOutputData(field, data) {
+  const schema = field.output;
+  if (!schema) return { success: true, data };
+  const result = schema.validate(data);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  const errors = result.issues.map((issue) => ({
+    ...issue,
+    path: ["output", ...issue.path]
+  }));
+  return { success: false, errors };
+}
+function validateContextData(field, context) {
+  const schema = field.context;
+  if (!schema) return { success: true, data: context };
+  const result = schema.validate(context);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  const errors = result.issues.map((issue) => ({
+    ...issue,
+    path: ["context", ...issue.path]
+  }));
+  return { success: false, errors };
+}
+function generateRequestId() {
+  return `gql_${crypto.randomUUID()}`;
+}
+
+// src/presentation/graphql/server/graphql-routes-builder.ts
+var GraphQLRoutesBuilderImpl = class _GraphQLRoutesBuilderImpl {
+  schema;
+  handlers;
+  constructor(schema, handlers) {
+    this.schema = schema;
+    this.handlers = handlers ?? /* @__PURE__ */ new Map();
+  }
+  handle(key, handlerOrConfig) {
+    const config = typeof handlerOrConfig === "function" ? { handler: handlerOrConfig } : handlerOrConfig;
+    const newHandlers = new Map(this.handlers);
+    newHandlers.set(key, config);
+    return new _GraphQLRoutesBuilderImpl(
+      this.schema,
+      newHandlers
+    );
+  }
+  handleWithUseCase(key, config) {
+    const newHandlers = new Map(this.handlers);
+    newHandlers.set(
+      key,
+      config
+    );
+    return new _GraphQLRoutesBuilderImpl(
+      this.schema,
+      newHandlers
+    );
+  }
+  build(options) {
+    return createGraphQLRoutesInternal(this.schema, Object.fromEntries(this.handlers), options);
+  }
+  buildPartial(options) {
+    return createGraphQLRoutesInternal(this.schema, Object.fromEntries(this.handlers), {
+      ...options,
+      allowPartial: true
+    });
+  }
+};
+function graphqlRoutes(schema) {
+  return new GraphQLRoutesBuilderImpl(schema);
+}
+
+// src/presentation/graphql/sdl/generate.ts
+function generateGraphQLSDL(schema, config) {
+  const fields = isSchemaDefinition(schema) ? schema.fields : schema;
+  const collectedFields = collectFields(fields);
+  const includeDescriptions = config?.includeDescriptions ?? true;
+  const includeDeprecations = config?.includeDeprecations ?? true;
+  const queries = [];
+  const mutations = [];
+  const subscriptions = [];
+  for (const { key, field } of collectedFields) {
+    const fieldId = generateFieldId(key);
+    if (field.operation === "query") {
+      queries.push({ fieldId, field });
+    } else if (field.operation === "mutation") {
+      mutations.push({ fieldId, field });
+    } else if (field.operation === "subscription") {
+      subscriptions.push({ fieldId, field });
+    }
+  }
+  const namedTypes = /* @__PURE__ */ new Map();
+  const lines = [];
+  if (config?.preamble) {
+    lines.push(config.preamble);
+    lines.push("");
+  }
+  if (queries.length > 0) {
+    lines.push("type Query {");
+    for (const { fieldId, field } of queries) {
+      const fieldLine = buildFieldLine(
+        fieldId,
+        field,
+        namedTypes,
+        includeDescriptions,
+        includeDeprecations
+      );
+      lines.push(fieldLine);
+    }
+    lines.push("}");
+    lines.push("");
+  }
+  if (mutations.length > 0) {
+    lines.push("type Mutation {");
+    for (const { fieldId, field } of mutations) {
+      const fieldLine = buildFieldLine(
+        fieldId,
+        field,
+        namedTypes,
+        includeDescriptions,
+        includeDeprecations
+      );
+      lines.push(fieldLine);
+    }
+    lines.push("}");
+    lines.push("");
+  }
+  if (subscriptions.length > 0) {
+    lines.push("type Subscription {");
+    for (const { fieldId, field } of subscriptions) {
+      const fieldLine = buildFieldLine(
+        fieldId,
+        field,
+        namedTypes,
+        includeDescriptions,
+        includeDeprecations
+      );
+      lines.push(fieldLine);
+    }
+    lines.push("}");
+    lines.push("");
+  }
+  for (const [, typeBody] of namedTypes) {
+    lines.push(typeBody);
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd() + "\n";
+}
+function buildFieldLine(fieldId, field, namedTypes, includeDescriptions, includeDeprecations) {
+  const parts = [];
+  if (includeDescriptions && field.docs.description) {
+    const escaped = field.docs.description.replace(/"""/g, '\\"""');
+    parts.push(`  """${escaped}"""`);
+  }
+  const inputTypeName = field.input ? `${capitalize(fieldId)}Input` : void 0;
+  const outputTypeName = field.output ? `${capitalize(fieldId)}Output` : void 0;
+  if (field.input && inputTypeName) {
+    const jsonSchema = field.input.toJsonSchema();
+    namedTypes.set(inputTypeName, buildInputType(inputTypeName, jsonSchema));
+  }
+  if (field.output && outputTypeName) {
+    const jsonSchema = field.output.toJsonSchema();
+    namedTypes.set(outputTypeName, buildOutputType(outputTypeName, jsonSchema));
+  }
+  let signature = `  ${fieldId}`;
+  if (inputTypeName) {
+    signature += `(input: ${inputTypeName}!)`;
+  }
+  signature += ": ";
+  signature += outputTypeName ?? "JSON";
+  if (includeDeprecations && field.docs.deprecated) {
+    const reason = field.docs.deprecationReason;
+    signature += reason ? ` @deprecated(reason: "${escapeSDLString(reason)}")` : " @deprecated";
+  }
+  if (parts.length > 0) {
+    return parts.join("\n") + "\n" + signature;
+  }
+  return signature;
+}
+function buildInputType(typeName, jsonSchema) {
+  const lines = [`input ${typeName} {`];
+  if (jsonSchema.properties && typeof jsonSchema.properties === "object") {
+    const required = new Set(
+      Array.isArray(jsonSchema.required) ? jsonSchema.required : []
+    );
+    for (const [propName, propSchema] of Object.entries(
+      jsonSchema.properties
+    )) {
+      const graphqlType = jsonSchemaToGraphQLType(propSchema);
+      const isRequired = required.has(propName);
+      lines.push(`  ${propName}: ${graphqlType}${isRequired ? "!" : ""}`);
+    }
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+function buildOutputType(typeName, jsonSchema) {
+  const lines = [`type ${typeName} {`];
+  if (jsonSchema.properties && typeof jsonSchema.properties === "object") {
+    const required = new Set(
+      Array.isArray(jsonSchema.required) ? jsonSchema.required : []
+    );
+    for (const [propName, propSchema] of Object.entries(
+      jsonSchema.properties
+    )) {
+      const graphqlType = jsonSchemaToGraphQLType(propSchema);
+      const isRequired = required.has(propName);
+      lines.push(`  ${propName}: ${graphqlType}${isRequired ? "!" : ""}`);
+    }
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+function jsonSchemaToGraphQLType(schema) {
+  if (!schema || typeof schema !== "object") return "JSON";
+  if (schema.enum && Array.isArray(schema.enum)) {
+    return "String";
+  }
+  const type = schema.type;
+  switch (type) {
+    case "string":
+      return "String";
+    case "integer":
+      return "Int";
+    case "number":
+      return "Float";
+    case "boolean":
+      return "Boolean";
+    case "array": {
+      const items = schema.items;
+      if (items) {
+        return `[${jsonSchemaToGraphQLType(items)}]`;
+      }
+      return "[JSON]";
+    }
+    case "object":
+      return "JSON";
+    default:
+      if (schema.oneOf || schema.anyOf || schema.allOf) {
+        return "JSON";
+      }
+      if (schema.properties) {
+        return "JSON";
+      }
+      return "JSON";
+  }
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function escapeSDLString(str) {
+  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
+
 // src/global/utils/field-changed.util.ts
 function fieldChanged({
   value,
@@ -1766,7 +2423,22 @@ function fieldChanged({
   UnauthorizedError,
   UnprocessableError,
   UseCaseError,
+  collectFields,
+  defineGraphQLSchema,
+  defineMutation,
+  defineQuery,
+  defineSubscription,
   fieldChanged,
+  generateFieldId,
+  generateGraphQLSDL,
+  getGraphQLErrorCode,
+  graphqlRoutes,
+  isFieldDefinition,
+  isSchemaDefinition,
+  isSimpleGraphQLHandlerConfig,
+  mapErrorToGraphQLError,
+  mergeGraphQLSchemas,
+  shouldMaskGraphQLError,
   wrapError,
   wrapErrorAsync,
   wrapErrorUnless,