khata-ui/react-openapi/utils/openapi_loader.ts

import SwaggerParser from "@apidevtools/swagger-parser";
import { AppConfig, ResourceConfig, ResourceField, FieldType } from "../types/config";

/**
 * Maps OpenAPI property types to our internal FieldType
 */
function mapOpenApiType(prop: any): FieldType {
  const type = prop.type;
  const format = prop.format;

  if (format === "date-time") return "datetime";
  if (format === "date") return "date";
  if (prop.enum) return "enum";
  if (
    type === "string" &&
    (prop.description?.toLowerCase().includes("image") ||
      prop.name?.toLowerCase().includes("icon"))
  )
    return "image";

  switch (type) {
    case "integer":
    case "number":
      return "number";
    case "boolean":
      return "boolean";
    case "object":
      return "object";
    case "array":
      return "array";
    default:
      return "string";
  }
}

/**
 * Recursively converts OpenAPI schemas to ResourceField map
 */
function mergeProperties(schema: any): { properties: Record<string, any>; required: string[] } {
  let properties: Record<string, any> = {};
  let required: string[] = [];

  if (schema.allOf) {
    for (const sub of schema.allOf) {
      const merged = mergeProperties(sub);
      properties = { ...properties, ...merged.properties };
      required = [...required, ...merged.required];
    }
  }
  if (schema.properties) {
    properties = { ...properties, ...schema.properties };
  }
  if (schema.required) {
    required = [...required, ...schema.required];
  }
  return { properties, required };
}

function parseSchemaFields(
  schema: any,
  resourceName: string,
  schemaToResourceMap: Map<any, string>,
  configuration: Record<string, any> = {}
): Record<string, ResourceField> {
  const fields: Record<string, ResourceField> = {};
  const { properties, required } = mergeProperties(schema);
  const overrides = configuration[resourceName]?.fields || {};
  console.log('inside parseSchemaFields configuration...', configuration['accounts']['referenceOptions'])

  for (const [key, prop] of Object.entries(properties) as [string, any]) {
    // Resolve oneOf/anyOf by merging all branch properties
    let resolvedProp = prop;
    if (prop.oneOf || prop.anyOf) {
      const branches = prop.oneOf || prop.anyOf;
      const merged = mergeProperties({ allOf: branches });
      resolvedProp = { ...prop, type: 'object', properties: merged.properties, required: merged.required };
    }

    const type = mapOpenApiType(resolvedProp);
    if (type === 'enum' && (!resolvedProp.enum || resolvedProp.enum.length === 0)) {
      throw new Error(
        `OpenAPI schema error: field "${resourceName}.${key}" is type "enum" but has no enum values. ` +
        `Add an "enum" array with at least one value to the OpenAPI schema definition.`
      );
    }
    const override = overrides[key];

    // Explicitly skip 'id' as it's the primary key and handled elsewhere
    if (key === "id" || override?.display === false) continue;

    fields[key] = {
      type,
      label:
        resolvedProp.title ||
        key.charAt(0).toUpperCase() + key.slice(1).replace(/_/g, " "),
      required: required.includes(key),
      options: resolvedProp.enum,
      readOnly:
        resolvedProp.readOnly ||
        key === "created_at" ||
        key === "updated_at",
      ...override,
    };

    // STRICT RELATION DETECTION
    // A field is a relation ONLY if its schema object (or items schema) 
    // exactly matches a schema that is defined as a resource.
    let targetSchema = resolvedProp;
    if (type === "array" && resolvedProp.items) {
      targetSchema = resolvedProp.items;
    }

    // Check if this schema object is registered as a resource
    const relation = schemaToResourceMap.get(targetSchema);
    if (relation) {
      fields[key].relation = relation;

        // Propagate enumOption from target resource config, or derive from target schema
        const explicitEnumOption = configuration[relation].referenceOptions.enumOption;
        console.log('if relation configuration...', configuration['accounts']['referenceOptions'])
        if (explicitEnumOption) {
          fields[key].enumOption = explicitEnumOption;
        } else {
          // No explicit enumOption supplied – this is a configuration error.
          // We abort loading so the problem is visible immediately.
          throw new Error(
            `Missing enumOption for relation "${relation}" on field "${key}". ` +
            `Define referenceOptions.enumOption in the configuration for resource "${relation}".`
          );
        }

    }

    // Recursively parse nested objects (only if not a relation)
    if (fields[key].type === "object" && resolvedProp.properties && !relation) {
      console.log('recursive configuration...', configuration['accounts']['referenceOptions'])
      fields[key].schema = parseSchemaFields(resolvedProp, resourceName, schemaToResourceMap, configuration);
    }
  }

  return fields;
}

/**
 * Scans paths to identify resources and their basic configuration
 */
export async function loadConfigFromOpenApi(baseUrl: string, configuration: Record<string, any> = {}, profileConfiguration: any = {}): Promise<AppConfig> {
  console.log('init configuration...', configuration['accounts']['referenceOptions'])
  // Use SwaggerParser to dereference the spec.
  // Dereferencing preserves object identity for $ref targets.
  const api = await SwaggerParser.dereference(
    new URL("/openapi.json", baseUrl).href
  );

  const resources: ResourceConfig[] = [];
  const paths = api.paths || {};

  // Group paths by base resource name
  const resourcePaths: Record<string, any> = {};
  for (const path of Object.keys(paths)) {
    const base = path.split("/")[1];
    if (!base) continue;

    if (!resourcePaths[base]) resourcePaths[base] = { path, methods: [] };
    const methods = Object.keys(paths[path] || {});
    resourcePaths[base].methods.push(...methods);

    // Identify the list endpoint for this resource
    if (!resourcePaths[base].listPath && !path.includes("{") && paths[path]?.get?.responses?.["200"]) {
      resourcePaths[base].listPath = path;
    }
  }

  // 1. Identify which schema objects correspond to which resources
  const schemaToResourceMap = new Map<any, string>();
  for (const [name, info] of Object.entries(resourcePaths)) {
    const listPath = info.listPath || `/${name}`;
    const listOp = paths[listPath]?.get;
    if (!listOp) continue;

    // @ts-ignore
    const responseSchema = listOp.responses?.["200"]?.content?.["application/json"]?.schema;
    let schemaObj = responseSchema;
    if (responseSchema?.type === "array" && responseSchema.items) {
      schemaObj = responseSchema.items;
    }

    if (schemaObj) {
      schemaToResourceMap.set(schemaObj, name);
      resourcePaths[name].schemaObj = schemaObj;
    }
  }

  // 2. Generate ResourceConfig for each identified resource
  for (const [name, info] of Object.entries(resourcePaths)) {
    const listPath = info.listPath || `/${name}`;
    const listOp = paths[listPath]?.get;
    if (!listOp || !info.schemaObj) continue;

    const schema = info.schemaObj;
    const label = name.charAt(0).toUpperCase() + name.slice(1, -1);
    const pluralLabel = name.charAt(0).toUpperCase() + name.slice(1);

    console.log('before parseSchemaFields configuration...', configuration['accounts']['referenceOptions'])
    const fields = parseSchemaFields(schema, name, schemaToResourceMap, configuration);

    const resourceOverride = configuration[name] || {};

    const fo = resourceOverride.filterOptions || {};

    resources.push({
      name,
      label: schema.title || label,
      pluralLabel: pluralLabel,
      endpoint: listPath,
      primaryKey: "id",
      fields,
      pagination: resourceOverride.pagination,
      hidden: resourceOverride.hidden,
      filterOptions: {
        mode: fo.mode || "server",
        fields: fo.fields,
      },
    });
  }

  // Collect standalone enum schemas (e.g. FetchRequestStatus, AccountType, etc.)
  const enums: Record<string, string[]> = {};
  const apiDoc = api as any;
  if (apiDoc.components?.schemas) {
    for (const [name, schema] of Object.entries(apiDoc.components.schemas) as [string, any]) {
      if (schema.enum) {
        enums[name] = schema.enum;
      }
    }
  }

  // @ts-ignore
  const serverBaseUrl = import.meta.env.VITE_API_BASE_URL || (api.servers?.[0]?.url ?? "")
  // @ts-ignore
  const authBaseUrl = import.meta.env.VITE_AUTH_BASE_URL || ""
  return {
    baseUrl: serverBaseUrl,
    authBaseUrl: authBaseUrl,
    resources,
    enums,
    profile: profileConfiguration,
  };
}