@famgia/omnify-core 0.0.1

package/dist/index.cjs

@@ -0,0 +1,2018 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Omnify: () => Omnify,
+  OmnifyError: () => OmnifyError,
+  PluginManager: () => PluginManager,
+  atlasError: () => atlasError,
+  atlasNotFoundError: () => atlasNotFoundError,
+  circularReferenceError: () => circularReferenceError,
+  configError: () => configError,
+  configNotFoundError: () => configNotFoundError,
+  createOmnify: () => createOmnify,
+  createPluginManager: () => createPluginManager,
+  duplicateSchemaError: () => duplicateSchemaError,
+  err: () => import_omnify_types.err,
+  expandProperty: () => expandProperty,
+  expandSchema: () => expandSchema,
+  expandSchemaProperties: () => expandSchemaProperties,
+  expandSchemas: () => expandSchemas,
+  fileNameToSchemaName: () => fileNameToSchemaName,
+  findReferencedSchemas: () => findReferencedSchemas,
+  findReferencingSchemas: () => findReferencingSchemas,
+  formatError: () => formatError,
+  formatErrorPlain: () => formatErrorPlain,
+  formatErrorSummary: () => formatErrorSummary,
+  generationError: () => generationError,
+  getAssociationMetadata: () => getAssociationMetadata,
+  getCustomTypeNames: () => getCustomTypeNames,
+  getEntitySchemas: () => getEntitySchemas,
+  getEnumSchemas: () => getEnumSchemas,
+  getExitCode: () => getExitCode,
+  getGroups: () => getGroups,
+  getPropertyMetadata: () => getPropertyMetadata,
+  getRelationshipGraph: () => getRelationshipGraph,
+  getSchemaMetadata: () => getSchemaMetadata,
+  getSchemaNames: () => getSchemaNames,
+  getSchemasByGroup: () => getSchemasByGroup,
+  getSchemasByKind: () => getSchemasByKind,
+  getTopologicalOrder: () => getTopologicalOrder,
+  getTypeInfo: () => getTypeInfo,
+  hasCircularReferences: () => hasCircularReferences,
+  internalError: () => internalError,
+  introspectSchema: () => introspectSchema,
+  introspectSchemas: () => introspectSchemas,
+  invalidAssociationTargetError: () => invalidAssociationTargetError,
+  invalidConfigError: () => invalidConfigError,
+  invalidPropertyTypeError: () => invalidPropertyTypeError,
+  isCompoundType: () => isCompoundType,
+  jsonSyntaxError: () => jsonSyntaxError,
+  loadSchema: () => loadSchema,
+  loadSchemas: () => loadSchemas,
+  missingConfigFieldError: () => missingConfigFieldError,
+  missingFieldError: () => missingFieldError,
+  notImplementedError: () => notImplementedError,
+  ok: () => import_omnify_types.ok,
+  outputWriteError: () => outputWriteError,
+  parseJsonSchema: () => parseJsonSchema,
+  parseYamlSchema: () => parseYamlSchema,
+  pluginError: () => pluginError,
+  pluginNotFoundError: () => pluginNotFoundError,
+  pluginTypeConflictError: () => pluginTypeConflictError,
+  schemaNotFoundError: () => schemaNotFoundError,
+  schemaParseError: () => schemaParseError,
+  validateAssociations: () => validateAssociations,
+  validateEnumSchema: () => validateEnumSchema,
+  validateOptions: () => validateOptions,
+  validateProperties: () => validateProperties,
+  validatePropertyType: () => validatePropertyType,
+  validateSchema: () => validateSchema,
+  validateSchemas: () => validateSchemas,
+  validationError: () => validationError,
+  yamlSyntaxError: () => yamlSyntaxError
+});
+module.exports = __toCommonJS(index_exports);
+var import_omnify_types = require("@famgia/omnify-types");
+
+// src/errors/omnify-error.ts
+var OmnifyError = class _OmnifyError extends Error {
+  /** Error code (e.g., 'E201') */
+  code;
+  /** Source location where the error occurred */
+  location;
+  /** Suggested fix for the error */
+  suggestion;
+  /** Additional context or details */
+  details;
+  /** Original error if this wraps another error */
+  cause;
+  constructor(message, code, location, suggestion, options) {
+    super(message);
+    this.name = "OmnifyError";
+    this.code = code;
+    if (location !== void 0) {
+      this.location = location;
+    }
+    if (suggestion !== void 0) {
+      this.suggestion = suggestion;
+    }
+    if (options?.details !== void 0) {
+      this.details = options.details;
+    }
+    if (options?.cause !== void 0) {
+      this.cause = options.cause;
+    }
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _OmnifyError);
+    }
+  }
+  /**
+   * Creates an OmnifyError from an OmnifyErrorInfo object.
+   */
+  static fromInfo(info) {
+    const options = {};
+    if (info.details !== void 0) {
+      options.details = info.details;
+    }
+    if (info.cause !== void 0) {
+      options.cause = info.cause;
+    }
+    return new _OmnifyError(
+      info.message,
+      info.code,
+      info.location,
+      info.suggestion,
+      Object.keys(options).length > 0 ? options : void 0
+    );
+  }
+  /**
+   * Wraps an unknown error as an OmnifyError.
+   * Useful for catching and re-throwing with context.
+   */
+  static wrap(error, code = "E901", location) {
+    if (error instanceof _OmnifyError) {
+      return error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    if (error instanceof Error) {
+      return new _OmnifyError(message, code, location, void 0, { cause: error });
+    }
+    return new _OmnifyError(message, code, location);
+  }
+  /**
+   * Converts to OmnifyErrorInfo for serialization.
+   */
+  toInfo() {
+    const info = {
+      code: this.code,
+      message: this.message
+    };
+    if (this.location !== void 0) {
+      info.location = this.location;
+    }
+    if (this.suggestion !== void 0) {
+      info.suggestion = this.suggestion;
+    }
+    if (this.details !== void 0) {
+      info.details = this.details;
+    }
+    if (this.cause !== void 0) {
+      info.cause = this.cause;
+    }
+    return info;
+  }
+  /**
+   * Returns a formatted string representation.
+   * Format: "Error [CODE]: message\n  --> file:line:column"
+   */
+  toString() {
+    const parts = [];
+    parts.push(`Error [${this.code}]: ${this.message}`);
+    if (this.location?.file) {
+      const loc = this.location;
+      let locationStr = `  --> ${loc.file}`;
+      if (loc.line !== void 0) {
+        locationStr += `:${loc.line}`;
+        if (loc.column !== void 0) {
+          locationStr += `:${loc.column}`;
+        }
+      }
+      parts.push(locationStr);
+    }
+    if (this.suggestion) {
+      parts.push(`  Suggestion: ${this.suggestion}`);
+    }
+    return parts.join("\n");
+  }
+  /**
+   * Returns the file path from location, if available.
+   */
+  get file() {
+    return this.location?.file;
+  }
+  /**
+   * Returns the line number from location, if available.
+   */
+  get line() {
+    return this.location?.line;
+  }
+  /**
+   * Returns the column number from location, if available.
+   */
+  get column() {
+    return this.location?.column;
+  }
+};
+
+// src/errors/formatter.ts
+var colors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m",
+  gray: "\x1B[90m"
+};
+function colorize(text, colorCode, enabled) {
+  return enabled ? `${colorCode}${text}${colors.reset}` : text;
+}
+function formatError(error, options = {}) {
+  const {
+    color = true,
+    showContext = true,
+    contextLines = 2,
+    sourceContent
+  } = options;
+  const lines = [];
+  const errorLabel = colorize("error", colors.red + colors.bold, color);
+  const code = colorize(`[${error.code}]`, colors.red, color);
+  const message = colorize(error.message, colors.bold, color);
+  lines.push(`${errorLabel}${code}: ${message}`);
+  const locFile = error.location?.file;
+  if (locFile !== void 0) {
+    const loc = error.location;
+    let locationStr = colorize("  --> ", colors.blue, color);
+    locationStr += colorize(locFile, colors.cyan, color);
+    if (loc?.line !== void 0) {
+      locationStr += `:${loc.line}`;
+      if (loc.column !== void 0) {
+        locationStr += `:${loc.column}`;
+      }
+    }
+    lines.push(locationStr);
+  }
+  if (showContext && sourceContent && error.location?.line !== void 0) {
+    const contextOutput = formatSourceContext(
+      sourceContent,
+      error.location.line,
+      error.location.column,
+      error.suggestion,
+      contextLines,
+      color
+    );
+    lines.push(contextOutput);
+  }
+  if (error.suggestion && (!showContext || !sourceContent)) {
+    const suggestionLabel = colorize("  = suggestion:", colors.cyan, color);
+    lines.push(`${suggestionLabel} ${error.suggestion}`);
+  }
+  return lines.join("\n");
+}
+function formatSourceContext(source, errorLine, errorColumn, suggestion, contextCount, colorEnabled) {
+  const sourceLines = source.split("\n");
+  const startLine = Math.max(1, errorLine - contextCount);
+  const endLine = Math.min(sourceLines.length, errorLine + contextCount);
+  const gutterWidth = String(endLine).length;
+  const output = [];
+  output.push(colorize(`${" ".repeat(gutterWidth)} |`, colors.blue, colorEnabled));
+  for (let i = startLine; i <= endLine; i++) {
+    const lineContent = sourceLines[i - 1] ?? "";
+    const lineNum = String(i).padStart(gutterWidth, " ");
+    const gutter = colorize(`${lineNum} |`, colors.blue, colorEnabled);
+    output.push(`${gutter} ${lineContent}`);
+    if (i === errorLine && errorColumn !== void 0) {
+      const underlineGutter = colorize(
+        `${" ".repeat(gutterWidth)} |`,
+        colors.blue,
+        colorEnabled
+      );
+      const spaces = " ".repeat(errorColumn - 1);
+      const underline = colorize("^", colors.red, colorEnabled);
+      let underlineLine = `${underlineGutter} ${spaces}${underline}`;
+      if (suggestion) {
+        underlineLine += ` ${colorize(suggestion, colors.yellow, colorEnabled)}`;
+      }
+      output.push(underlineLine);
+    }
+  }
+  output.push(colorize(`${" ".repeat(gutterWidth)} |`, colors.blue, colorEnabled));
+  return output.join("\n");
+}
+function formatErrorSummary(errors, options = {}) {
+  const { color = true } = options;
+  if (errors.length === 0) {
+    return "";
+  }
+  const formattedErrors = errors.map((e) => formatError(e, options));
+  const summary = colorize(
+    `
+Found ${errors.length} error${errors.length === 1 ? "" : "s"}`,
+    colors.red + colors.bold,
+    color
+  );
+  return formattedErrors.join("\n\n") + summary;
+}
+function formatErrorPlain(error) {
+  return formatError(error, { color: false, showContext: false });
+}
+function getExitCode(error) {
+  const category = error.code.charAt(1);
+  switch (category) {
+    case "0":
+      return 3;
+    case "2":
+      return 2;
+    default:
+      return 1;
+  }
+}
+
+// src/errors/factories.ts
+function buildLocation(file, line, column) {
+  const loc = { file };
+  if (line !== void 0) {
+    loc.line = line;
+  }
+  if (column !== void 0) {
+    loc.column = column;
+  }
+  return loc;
+}
+function buildOptions(cause) {
+  return cause !== void 0 ? { cause } : void 0;
+}
+function configError(message, code = "E002", suggestion) {
+  return new OmnifyError(message, code, void 0, suggestion);
+}
+function configNotFoundError(configPath) {
+  return new OmnifyError(
+    `Configuration file not found: ${configPath}`,
+    "E001",
+    { file: configPath },
+    "Run `omnify init` to create a configuration file"
+  );
+}
+function invalidConfigError(message, configPath) {
+  return new OmnifyError(
+    message,
+    "E002",
+    { file: configPath },
+    "Check your omnify.config.ts for syntax errors"
+  );
+}
+function missingConfigFieldError(field, configPath) {
+  return new OmnifyError(
+    `Missing required configuration field: ${field}`,
+    "E003",
+    { file: configPath },
+    `Add '${field}' to your configuration file`
+  );
+}
+function schemaParseError(message, location, suggestion) {
+  return new OmnifyError(message, "E102", location, suggestion);
+}
+function schemaNotFoundError(schemaPath) {
+  return new OmnifyError(
+    `Schema file not found: ${schemaPath}`,
+    "E101",
+    { file: schemaPath },
+    "Check that the file exists and the path is correct"
+  );
+}
+function yamlSyntaxError(message, file, line, column) {
+  return new OmnifyError(
+    `Invalid YAML syntax: ${message}`,
+    "E102",
+    buildLocation(file, line, column),
+    "Check for proper indentation and YAML syntax"
+  );
+}
+function jsonSyntaxError(message, file, line, column) {
+  return new OmnifyError(
+    `Invalid JSON syntax: ${message}`,
+    "E103",
+    buildLocation(file, line, column),
+    "Check for proper JSON syntax (quotes, commas, brackets)"
+  );
+}
+function validationError(message, location, suggestion) {
+  return new OmnifyError(message, "E202", location, suggestion);
+}
+function invalidPropertyTypeError(typeName, location, validTypes) {
+  const suggestion = validTypes ? `Use one of: ${validTypes.slice(0, 5).join(", ")}${validTypes.length > 5 ? ", ..." : ""}` : void 0;
+  return new OmnifyError(
+    `Invalid property type '${typeName}'`,
+    "E201",
+    location,
+    suggestion
+  );
+}
+function missingFieldError(field, location) {
+  return new OmnifyError(
+    `Missing required field: ${field}`,
+    "E202",
+    location,
+    `Add '${field}' to the schema definition`
+  );
+}
+function invalidAssociationTargetError(target, location, availableSchemas) {
+  const suggestion = availableSchemas ? `Available schemas: ${availableSchemas.slice(0, 5).join(", ")}${availableSchemas.length > 5 ? ", ..." : ""}` : "Check that the target schema exists";
+  return new OmnifyError(
+    `Invalid association target '${target}'`,
+    "E203",
+    location,
+    suggestion
+  );
+}
+function circularReferenceError(path2, location) {
+  return new OmnifyError(
+    `Circular reference detected: ${path2.join(" -> ")}`,
+    "E204",
+    location,
+    "Remove the circular dependency or use a unidirectional relationship"
+  );
+}
+function duplicateSchemaError(name, location, existingLocation) {
+  const suggestion = existingLocation?.file ? `Schema already defined in ${existingLocation.file}` : "Rename one of the schemas to avoid the conflict";
+  return new OmnifyError(
+    `Duplicate schema name '${name}'`,
+    "E205",
+    location,
+    suggestion
+  );
+}
+function pluginError(message, pluginName, cause) {
+  return new OmnifyError(
+    message,
+    "E302",
+    void 0,
+    `Check the plugin '${pluginName}' for issues`,
+    buildOptions(cause)
+  );
+}
+function pluginNotFoundError(pluginName) {
+  return new OmnifyError(
+    `Plugin not found: ${pluginName}`,
+    "E301",
+    void 0,
+    `Install the plugin with: npm install ${pluginName}`
+  );
+}
+function pluginTypeConflictError(typeName, pluginA, pluginB) {
+  return new OmnifyError(
+    `Type '${typeName}' is defined by multiple plugins: ${pluginA}, ${pluginB}`,
+    "E304",
+    void 0,
+    "Remove one of the conflicting plugins or rename the type"
+  );
+}
+function atlasError(message, cause) {
+  return new OmnifyError(
+    message,
+    "E402",
+    void 0,
+    "Check Atlas CLI output for details",
+    buildOptions(cause)
+  );
+}
+function atlasNotFoundError() {
+  return new OmnifyError(
+    "Atlas CLI not found",
+    "E401",
+    void 0,
+    "Install Atlas CLI: https://atlasgo.io/getting-started"
+  );
+}
+function generationError(message, outputPath, cause) {
+  return new OmnifyError(
+    message,
+    "E501",
+    outputPath ? { file: outputPath } : void 0,
+    void 0,
+    buildOptions(cause)
+  );
+}
+function outputWriteError(outputPath, cause) {
+  return new OmnifyError(
+    `Failed to write output file: ${outputPath}`,
+    "E503",
+    { file: outputPath },
+    "Check file permissions and disk space",
+    buildOptions(cause)
+  );
+}
+function internalError(message, cause) {
+  return new OmnifyError(
+    message,
+    "E901",
+    void 0,
+    "This is a bug. Please report it at https://github.com/omnify/omnify-schema/issues",
+    buildOptions(cause)
+  );
+}
+function notImplementedError(feature) {
+  return new OmnifyError(
+    `Feature not implemented: ${feature}`,
+    "E902",
+    void 0,
+    "This feature is planned for a future release"
+  );
+}
+
+// src/schema/loader.ts
+var fs = __toESM(require("fs/promises"), 1);
+var path = __toESM(require("path"), 1);
+var import_js_yaml = __toESM(require("js-yaml"), 1);
+function fileNameToSchemaName(fileName) {
+  const baseName = path.basename(fileName, path.extname(fileName));
+  return baseName.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join("");
+}
+function parseYamlSchema(content, filePath) {
+  try {
+    const parsed = import_js_yaml.default.load(content);
+    if (parsed === null || typeof parsed !== "object") {
+      throw yamlSyntaxError("Schema must be a YAML object", filePath);
+    }
+    return buildSchemaDefinition(parsed);
+  } catch (error) {
+    if (error instanceof import_js_yaml.default.YAMLException) {
+      const line = error.mark?.line !== void 0 ? error.mark.line + 1 : void 0;
+      const column = error.mark?.column !== void 0 ? error.mark.column + 1 : void 0;
+      throw yamlSyntaxError(error.reason || error.message, filePath, line, column);
+    }
+    throw error;
+  }
+}
+function parseJsonSchema(content, filePath) {
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed === null || typeof parsed !== "object") {
+      throw jsonSyntaxError("Schema must be a JSON object", filePath);
+    }
+    return buildSchemaDefinition(parsed);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      const match = error.message.match(/position (\d+)/);
+      const positionStr = match?.[1];
+      const position = positionStr !== void 0 ? parseInt(positionStr, 10) : void 0;
+      let line;
+      let column;
+      if (position !== void 0) {
+        const beforeError = content.substring(0, position);
+        const lines = beforeError.split("\n");
+        line = lines.length;
+        const lastLine = lines[lines.length - 1];
+        column = (lastLine !== void 0 ? lastLine.length : 0) + 1;
+      }
+      throw jsonSyntaxError(error.message, filePath, line, column);
+    }
+    throw error;
+  }
+}
+function buildSchemaDefinition(data) {
+  const schema = {};
+  if (data.kind !== void 0) {
+    schema.kind = data.kind;
+  }
+  if (data.displayName !== void 0 && typeof data.displayName === "string") {
+    schema.displayName = data.displayName;
+  }
+  if (data.titleIndex !== void 0 && typeof data.titleIndex === "string") {
+    schema.titleIndex = data.titleIndex;
+  }
+  if (data.group !== void 0 && typeof data.group === "string") {
+    schema.group = data.group;
+  }
+  if (data.options !== void 0 && typeof data.options === "object") {
+    const options = buildSchemaOptions(data.options);
+    if (Object.keys(options).length > 0) {
+      schema.options = options;
+    }
+  }
+  if (data.properties !== void 0 && typeof data.properties === "object") {
+    const properties = buildProperties(data.properties);
+    if (Object.keys(properties).length > 0) {
+      schema.properties = properties;
+    }
+  }
+  if (data.values !== void 0 && Array.isArray(data.values)) {
+    schema.values = data.values;
+  }
+  return schema;
+}
+function buildSchemaOptions(data) {
+  const options = {};
+  if (data.timestamps !== void 0 && typeof data.timestamps === "boolean") {
+    options.timestamps = data.timestamps;
+  }
+  if (data.softDelete !== void 0 && typeof data.softDelete === "boolean") {
+    options.softDelete = data.softDelete;
+  }
+  if (data.unique !== void 0) {
+    options.unique = data.unique;
+  }
+  if (data.indexes !== void 0 && Array.isArray(data.indexes)) {
+    options.indexes = data.indexes;
+  }
+  if (data.translations !== void 0 && typeof data.translations === "boolean") {
+    options.translations = data.translations;
+  }
+  if (data.tableName !== void 0 && typeof data.tableName === "string") {
+    options.tableName = data.tableName;
+  }
+  if (data.primaryKeyType !== void 0) {
+    options.primaryKeyType = data.primaryKeyType;
+  }
+  if (data.authenticatable !== void 0 && typeof data.authenticatable === "boolean") {
+    options.authenticatable = data.authenticatable;
+  }
+  if (data.authenticatableLoginIdField !== void 0 && typeof data.authenticatableLoginIdField === "string") {
+    options.authenticatableLoginIdField = data.authenticatableLoginIdField;
+  }
+  if (data.authenticatablePasswordField !== void 0 && typeof data.authenticatablePasswordField === "string") {
+    options.authenticatablePasswordField = data.authenticatablePasswordField;
+  }
+  if (data.authenticatableGuardName !== void 0 && typeof data.authenticatableGuardName === "string") {
+    options.authenticatableGuardName = data.authenticatableGuardName;
+  }
+  return options;
+}
+function buildProperties(data) {
+  const properties = {};
+  for (const [name, value] of Object.entries(data)) {
+    if (value !== void 0 && typeof value === "object" && value !== null) {
+      properties[name] = buildPropertyDefinition(value);
+    }
+  }
+  return properties;
+}
+function buildPropertyDefinition(data) {
+  const prop = {
+    type: data.type || "String"
+  };
+  if (data.displayName !== void 0 && typeof data.displayName === "string") {
+    prop.displayName = data.displayName;
+  }
+  if (data.nullable !== void 0 && typeof data.nullable === "boolean") {
+    prop.nullable = data.nullable;
+  }
+  if (data.default !== void 0) {
+    prop.default = data.default;
+  }
+  if (data.unique !== void 0 && typeof data.unique === "boolean") {
+    prop.unique = data.unique;
+  }
+  if (data.description !== void 0 && typeof data.description === "string") {
+    prop.description = data.description;
+  }
+  if (data.length !== void 0 && typeof data.length === "number") {
+    prop.length = data.length;
+  }
+  if (data.unsigned !== void 0 && typeof data.unsigned === "boolean") {
+    prop.unsigned = data.unsigned;
+  }
+  if (data.precision !== void 0 && typeof data.precision === "number") {
+    prop.precision = data.precision;
+  }
+  if (data.scale !== void 0 && typeof data.scale === "number") {
+    prop.scale = data.scale;
+  }
+  if (data.enum !== void 0) {
+    prop.enum = data.enum;
+  }
+  if (data.options !== void 0 && Array.isArray(data.options)) {
+    prop.options = data.options;
+  }
+  if (data.source !== void 0 && typeof data.source === "string") {
+    prop.source = data.source;
+  }
+  if (data.relation !== void 0 && typeof data.relation === "string") {
+    prop.relation = data.relation;
+  }
+  if (data.target !== void 0 && typeof data.target === "string") {
+    prop.target = data.target;
+  }
+  if (data.inversedBy !== void 0 && typeof data.inversedBy === "string") {
+    prop.inversedBy = data.inversedBy;
+  }
+  if (data.mappedBy !== void 0 && typeof data.mappedBy === "string") {
+    prop.mappedBy = data.mappedBy;
+  }
+  if (data.onDelete !== void 0 && typeof data.onDelete === "string") {
+    prop.onDelete = data.onDelete;
+  }
+  if (data.onUpdate !== void 0 && typeof data.onUpdate === "string") {
+    prop.onUpdate = data.onUpdate;
+  }
+  if (data.owning !== void 0 && typeof data.owning === "boolean") {
+    prop.owning = data.owning;
+  }
+  if (data.joinTable !== void 0 && typeof data.joinTable === "string") {
+    prop.joinTable = data.joinTable;
+  }
+  return prop;
+}
+async function loadSchema(filePath, options = {}) {
+  const absolutePath = path.resolve(filePath);
+  const baseDir = options.baseDir ? path.resolve(options.baseDir) : path.dirname(absolutePath);
+  try {
+    await fs.access(absolutePath);
+  } catch {
+    throw schemaNotFoundError(filePath);
+  }
+  const content = await fs.readFile(absolutePath, "utf-8");
+  const ext = path.extname(absolutePath).toLowerCase();
+  const schemaDefinition = ext === ".json" ? parseJsonSchema(content, filePath) : parseYamlSchema(content, filePath);
+  const name = fileNameToSchemaName(absolutePath);
+  const relativePath = path.relative(baseDir, absolutePath);
+  const loadedSchema = {
+    ...schemaDefinition,
+    name,
+    filePath: absolutePath,
+    relativePath
+  };
+  return loadedSchema;
+}
+async function findSchemaFiles(dirPath, extensions, recursive) {
+  const files = [];
+  const entries = await fs.readdir(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dirPath, entry.name);
+    if (entry.isDirectory() && recursive) {
+      const subFiles = await findSchemaFiles(fullPath, extensions, recursive);
+      files.push(...subFiles);
+    } else if (entry.isFile()) {
+      const ext = path.extname(entry.name).toLowerCase();
+      if (extensions.includes(ext)) {
+        files.push(fullPath);
+      }
+    }
+  }
+  return files;
+}
+async function loadSchemas(directoryPath, options = {}) {
+  const {
+    extensions = [".yaml", ".yml", ".json"],
+    recursive = true
+  } = options;
+  const absoluteDir = path.resolve(directoryPath);
+  try {
+    const stat2 = await fs.stat(absoluteDir);
+    if (!stat2.isDirectory()) {
+      throw schemaNotFoundError(directoryPath);
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw schemaNotFoundError(directoryPath);
+    }
+    throw error;
+  }
+  const schemaFiles = await findSchemaFiles(absoluteDir, extensions, recursive);
+  const schemas = {};
+  const schemaLocations = {};
+  for (const filePath of schemaFiles) {
+    const schema = await loadSchema(filePath, { baseDir: absoluteDir });
+    const existingLocation = schemaLocations[schema.name];
+    if (existingLocation !== void 0) {
+      throw duplicateSchemaError(
+        schema.name,
+        { file: filePath },
+        { file: existingLocation }
+      );
+    }
+    schemas[schema.name] = schema;
+    schemaLocations[schema.name] = filePath;
+  }
+  return schemas;
+}
+
+// src/validation/validator.ts
+var BUILT_IN_TYPES = [
+  "String",
+  "Int",
+  "BigInt",
+  "Float",
+  "Boolean",
+  "Text",
+  "LongText",
+  "Date",
+  "Time",
+  "Timestamp",
+  "Json",
+  "Email",
+  "Password",
+  "File",
+  "MultiFile",
+  "Enum",
+  "Select",
+  "Lookup",
+  "Association",
+  "Polymorphic"
+];
+var VALID_RELATIONS = [
+  "OneToOne",
+  "OneToMany",
+  "ManyToOne",
+  "ManyToMany"
+];
+var VALID_REFERENTIAL_ACTIONS = [
+  "CASCADE",
+  "SET NULL",
+  "SET DEFAULT",
+  "RESTRICT",
+  "NO ACTION"
+];
+var VALID_PRIMARY_KEY_TYPES = ["Int", "BigInt", "Uuid", "String"];
+function buildLocation2(file, line, column) {
+  const loc = { file };
+  if (line !== void 0) {
+    loc.line = line;
+  }
+  if (column !== void 0) {
+    loc.column = column;
+  }
+  return loc;
+}
+function validatePropertyType(propertyName, property, filePath, customTypes = []) {
+  const errors = [];
+  const validTypes = [...BUILT_IN_TYPES, ...customTypes];
+  if (!property.type) {
+    errors.push(
+      missingFieldError("type", buildLocation2(filePath))
+    );
+    return errors;
+  }
+  if (!validTypes.includes(property.type)) {
+    errors.push(
+      invalidPropertyTypeError(
+        property.type,
+        buildLocation2(filePath),
+        BUILT_IN_TYPES
+      )
+    );
+  }
+  if (property.type === "Enum") {
+    const enumProp = property;
+    if (enumProp.enum === void 0) {
+      errors.push(
+        validationError(
+          `Property '${propertyName}' of type 'Enum' requires 'enum' field`,
+          buildLocation2(filePath),
+          "Add enum values: enum: [value1, value2]"
+        )
+      );
+    }
+  }
+  if (property.type === "Association") {
+    const assocProp = property;
+    if (assocProp.relation === void 0) {
+      errors.push(
+        validationError(
+          `Property '${propertyName}' of type 'Association' requires 'relation' field`,
+          buildLocation2(filePath),
+          "Add relation: OneToOne, OneToMany, ManyToOne, or ManyToMany"
+        )
+      );
+    }
+    if (assocProp.target === void 0) {
+      errors.push(
+        validationError(
+          `Property '${propertyName}' of type 'Association' requires 'target' field`,
+          buildLocation2(filePath),
+          "Add target schema name: target: User"
+        )
+      );
+    }
+  }
+  return errors;
+}
+function validateProperties(schema, filePath, customTypes = []) {
+  const errors = [];
+  if (!schema.properties) {
+    if (schema.kind !== "enum") {
+    }
+    return errors;
+  }
+  for (const [name, property] of Object.entries(schema.properties)) {
+    const propErrors = validatePropertyType(name, property, filePath, customTypes);
+    errors.push(...propErrors);
+  }
+  return errors;
+}
+function validateAssociations(schema, allSchemas) {
+  const errors = [];
+  if (!schema.properties) {
+    return errors;
+  }
+  const availableSchemas = Object.keys(allSchemas);
+  for (const [name, property] of Object.entries(schema.properties)) {
+    if (property.type !== "Association") {
+      continue;
+    }
+    const assocProp = property;
+    if (assocProp.relation && !VALID_RELATIONS.includes(assocProp.relation)) {
+      errors.push(
+        validationError(
+          `Property '${name}' has invalid relation '${assocProp.relation}'`,
+          buildLocation2(schema.filePath),
+          `Use one of: ${VALID_RELATIONS.join(", ")}`
+        )
+      );
+    }
+    if (assocProp.target && !availableSchemas.includes(assocProp.target)) {
+      errors.push(
+        invalidAssociationTargetError(
+          assocProp.target,
+          buildLocation2(schema.filePath),
+          availableSchemas
+        )
+      );
+    }
+    if (assocProp.inversedBy && assocProp.target) {
+      const targetSchema = allSchemas[assocProp.target];
+      if (targetSchema?.properties) {
+        const inverseProperty = targetSchema.properties[assocProp.inversedBy];
+        if (!inverseProperty) {
+          errors.push(
+            validationError(
+              `Property '${name}' references non-existent inverse property '${assocProp.inversedBy}' on '${assocProp.target}'`,
+              buildLocation2(schema.filePath),
+              `Add property '${assocProp.inversedBy}' to ${assocProp.target} schema`
+            )
+          );
+        }
+      }
+    }
+    if (assocProp.onDelete && !VALID_REFERENTIAL_ACTIONS.includes(assocProp.onDelete)) {
+      errors.push(
+        validationError(
+          `Property '${name}' has invalid onDelete action '${assocProp.onDelete}'`,
+          buildLocation2(schema.filePath),
+          `Use one of: ${VALID_REFERENTIAL_ACTIONS.join(", ")}`
+        )
+      );
+    }
+    if (assocProp.onUpdate && !VALID_REFERENTIAL_ACTIONS.includes(assocProp.onUpdate)) {
+      errors.push(
+        validationError(
+          `Property '${name}' has invalid onUpdate action '${assocProp.onUpdate}'`,
+          buildLocation2(schema.filePath),
+          `Use one of: ${VALID_REFERENTIAL_ACTIONS.join(", ")}`
+        )
+      );
+    }
+  }
+  return errors;
+}
+function validateOptions(schema, filePath) {
+  const errors = [];
+  const options = schema.options;
+  if (!options) {
+    return errors;
+  }
+  if (options.primaryKeyType !== void 0) {
+    if (!VALID_PRIMARY_KEY_TYPES.includes(options.primaryKeyType)) {
+      errors.push(
+        validationError(
+          `Invalid primaryKeyType '${options.primaryKeyType}'`,
+          buildLocation2(filePath),
+          `Use one of: ${VALID_PRIMARY_KEY_TYPES.join(", ")}`
+        )
+      );
+    }
+  }
+  if (options.unique && schema.properties) {
+    const propertyNames = Object.keys(schema.properties);
+    const uniqueConstraints = Array.isArray(options.unique[0]) ? options.unique : [options.unique];
+    for (const constraint of uniqueConstraints) {
+      for (const column of constraint) {
+        if (!propertyNames.includes(column)) {
+          errors.push(
+            validationError(
+              `Unique constraint references non-existent property '${column}'`,
+              buildLocation2(filePath),
+              `Available properties: ${propertyNames.join(", ")}`
+            )
+          );
+        }
+      }
+    }
+  }
+  if (options.indexes && schema.properties) {
+    const propertyNames = Object.keys(schema.properties);
+    for (const index of options.indexes) {
+      for (const column of index.columns) {
+        if (!propertyNames.includes(column)) {
+          errors.push(
+            validationError(
+              `Index references non-existent property '${column}'`,
+              buildLocation2(filePath),
+              `Available properties: ${propertyNames.join(", ")}`
+            )
+          );
+        }
+      }
+    }
+  }
+  if (options.authenticatable) {
+    if (options.authenticatableLoginIdField && schema.properties) {
+      if (!schema.properties[options.authenticatableLoginIdField]) {
+        errors.push(
+          validationError(
+            `authenticatableLoginIdField references non-existent property '${options.authenticatableLoginIdField}'`,
+            buildLocation2(filePath)
+          )
+        );
+      }
+    }
+    if (options.authenticatablePasswordField && schema.properties) {
+      if (!schema.properties[options.authenticatablePasswordField]) {
+        errors.push(
+          validationError(
+            `authenticatablePasswordField references non-existent property '${options.authenticatablePasswordField}'`,
+            buildLocation2(filePath)
+          )
+        );
+      }
+    }
+  }
+  return errors;
+}
+function validateEnumSchema(schema, filePath) {
+  const errors = [];
+  if (schema.kind !== "enum") {
+    return errors;
+  }
+  if (!schema.values || schema.values.length === 0) {
+    errors.push(
+      validationError(
+        "Enum schema requires at least one value",
+        buildLocation2(filePath),
+        "Add values: [value1, value2, ...]"
+      )
+    );
+  }
+  if (schema.values) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const value of schema.values) {
+      if (seen.has(value)) {
+        errors.push(
+          validationError(
+            `Duplicate enum value '${value}'`,
+            buildLocation2(filePath)
+          )
+        );
+      }
+      seen.add(value);
+    }
+  }
+  return errors;
+}
+function validateSchema(schema, options = {}) {
+  const errors = [];
+  const warnings = [];
+  const customTypes = options.customTypes ?? [];
+  const propErrors = validateProperties(schema, schema.filePath, customTypes);
+  errors.push(...propErrors);
+  const optErrors = validateOptions(schema, schema.filePath);
+  errors.push(...optErrors);
+  if (schema.kind === "enum") {
+    const enumErrors = validateEnumSchema(schema, schema.filePath);
+    errors.push(...enumErrors);
+  }
+  if (schema.titleIndex && schema.properties) {
+    if (!schema.properties[schema.titleIndex]) {
+      errors.push(
+        validationError(
+          `titleIndex references non-existent property '${schema.titleIndex}'`,
+          buildLocation2(schema.filePath),
+          `Available properties: ${Object.keys(schema.properties).join(", ")}`
+        )
+      );
+    }
+  }
+  return {
+    schemaName: schema.name,
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function validateSchemas(schemas, options = {}) {
+  const schemaResults = [];
+  const allErrors = [];
+  const allWarnings = [];
+  const validateAssocs = options.validateAssociations ?? true;
+  for (const schema of Object.values(schemas)) {
+    const result = validateSchema(schema, options);
+    schemaResults.push(result);
+    allErrors.push(...result.errors);
+    allWarnings.push(...result.warnings);
+  }
+  if (validateAssocs) {
+    for (const schema of Object.values(schemas)) {
+      const assocErrors = validateAssociations(schema, schemas);
+      allErrors.push(...assocErrors);
+      const existingResult = schemaResults.find((r) => r.schemaName === schema.name);
+      if (existingResult && assocErrors.length > 0) {
+        const updatedResult = {
+          ...existingResult,
+          valid: false,
+          errors: [...existingResult.errors, ...assocErrors]
+        };
+        const index = schemaResults.indexOf(existingResult);
+        schemaResults[index] = updatedResult;
+      }
+    }
+  }
+  return {
+    valid: allErrors.length === 0,
+    errorCount: allErrors.length,
+    warningCount: allWarnings.length,
+    schemas: schemaResults,
+    errors: allErrors,
+    warnings: allWarnings
+  };
+}
+
+// src/plugins/manager.ts
+var nullLogger = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+};
+var consoleLogger = {
+  debug: (msg) => console.log(`[plugin:debug] ${msg}`),
+  info: (msg) => console.log(`[plugin:info] ${msg}`),
+  warn: (msg) => console.warn(`[plugin:warn] ${msg}`),
+  error: (msg) => console.error(`[plugin:error] ${msg}`)
+};
+var PluginManager = class {
+  _plugins = /* @__PURE__ */ new Map();
+  _types = /* @__PURE__ */ new Map();
+  _cwd;
+  _verbose;
+  _logger;
+  constructor(options = {}) {
+    this._cwd = options.cwd ?? process.cwd();
+    this._verbose = options.verbose ?? false;
+    this._logger = options.logger ?? (this._verbose ? consoleLogger : nullLogger);
+  }
+  /**
+   * Creates a plugin context for plugin setup.
+   */
+  createContext() {
+    return {
+      cwd: this._cwd,
+      verbose: this._verbose,
+      logger: this._logger
+    };
+  }
+  /**
+   * Registers a single plugin.
+   */
+  async register(plugin) {
+    const warnings = [];
+    const registeredTypes = [];
+    if (this._plugins.has(plugin.name)) {
+      return {
+        success: false,
+        types: [],
+        warnings: [],
+        error: `Plugin '${plugin.name}' is already registered`
+      };
+    }
+    this._logger.debug(`Registering plugin: ${plugin.name}@${plugin.version}`);
+    if (plugin.setup) {
+      try {
+        await plugin.setup(this.createContext());
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          success: false,
+          types: [],
+          warnings: [],
+          error: `Plugin setup failed: ${message}`
+        };
+      }
+    }
+    if (plugin.types) {
+      for (const typeDef of plugin.types) {
+        const existing = this._types.get(typeDef.name);
+        if (existing) {
+          throw pluginTypeConflictError(
+            typeDef.name,
+            existing.pluginName,
+            plugin.name
+          );
+        }
+        const validationError2 = this.validateTypeDefinition(typeDef);
+        if (validationError2) {
+          warnings.push(`Type '${typeDef.name}': ${validationError2}`);
+          continue;
+        }
+        const registeredType = {
+          ...typeDef,
+          pluginName: plugin.name,
+          pluginVersion: plugin.version
+        };
+        this._types.set(typeDef.name, registeredType);
+        registeredTypes.push(registeredType);
+        this._logger.debug(`  Registered type: ${typeDef.name}`);
+      }
+    }
+    this._plugins.set(plugin.name, plugin);
+    this._logger.info(`Plugin registered: ${plugin.name} (${registeredTypes.length} types)`);
+    return {
+      success: true,
+      types: registeredTypes,
+      warnings
+    };
+  }
+  /**
+   * Registers multiple plugins.
+   */
+  async registerAll(plugins) {
+    for (const plugin of plugins) {
+      const result = await this.register(plugin);
+      if (!result.success) {
+        throw pluginError(result.error ?? "Unknown error", plugin.name);
+      }
+    }
+  }
+  /**
+   * Validates a type definition.
+   */
+  validateTypeDefinition(typeDef) {
+    if (!typeDef.name || typeDef.name.length === 0) {
+      return "Type name is required";
+    }
+    if (typeDef.compound) {
+      if (!typeDef.expand || typeDef.expand.length === 0) {
+        return "Compound type must have expand definitions";
+      }
+      for (const field of typeDef.expand) {
+        if (!field.suffix) {
+          return "Expanded field must have a suffix";
+        }
+        if (!field.sql || !field.sql.sqlType) {
+          return `Expanded field '${field.suffix}' must have SQL type`;
+        }
+        if (!field.typescript || !field.typescript.type) {
+          return `Expanded field '${field.suffix}' must have TypeScript type`;
+        }
+      }
+    } else {
+      if (!typeDef.sql || !typeDef.sql.sqlType) {
+        return "Non-compound type must have SQL definition";
+      }
+      if (!typeDef.typescript || !typeDef.typescript.type) {
+        return "Non-compound type must have TypeScript type";
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Unregisters a plugin and its types.
+   */
+  async unregister(pluginName) {
+    const plugin = this._plugins.get(pluginName);
+    if (!plugin) {
+      throw pluginNotFoundError(pluginName);
+    }
+    if (plugin.teardown) {
+      try {
+        await plugin.teardown();
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this._logger.warn(`Plugin teardown failed: ${message}`);
+      }
+    }
+    for (const [typeName, type] of this._types) {
+      if (type.pluginName === pluginName) {
+        this._types.delete(typeName);
+      }
+    }
+    this._plugins.delete(pluginName);
+    this._logger.info(`Plugin unregistered: ${pluginName}`);
+  }
+  /**
+   * Gets a registered type by name.
+   */
+  getType(typeName) {
+    return this._types.get(typeName);
+  }
+  /**
+   * Checks if a type is registered.
+   */
+  hasType(typeName) {
+    return this._types.has(typeName);
+  }
+  /**
+   * Gets all registered types.
+   */
+  getAllTypes() {
+    return this._types;
+  }
+  /**
+   * Gets all registered type names.
+   */
+  getTypeNames() {
+    return Array.from(this._types.keys());
+  }
+  /**
+   * Gets a registered plugin by name.
+   */
+  getPlugin(pluginName) {
+    return this._plugins.get(pluginName);
+  }
+  /**
+   * Gets all registered plugins.
+   */
+  getAllPlugins() {
+    return this._plugins;
+  }
+  /**
+   * Gets the current registry state.
+   */
+  getRegistry() {
+    return {
+      plugins: this._plugins,
+      types: this._types
+    };
+  }
+  /**
+   * Clears all registered plugins and types.
+   */
+  async clear() {
+    for (const plugin of this._plugins.values()) {
+      if (plugin.teardown) {
+        try {
+          await plugin.teardown();
+        } catch {
+        }
+      }
+    }
+    this._plugins.clear();
+    this._types.clear();
+    this._logger.debug("Plugin registry cleared");
+  }
+};
+function createPluginManager(options) {
+  return new PluginManager(options);
+}
+
+// src/plugins/expander.ts
+function expandProperty(propertyName, property, registry) {
+  const typeName = property.type;
+  const registeredType = registry.types.get(typeName);
+  if (!registeredType || !registeredType.compound || !registeredType.expand) {
+    return [{
+      originalName: propertyName,
+      expandedName: propertyName,
+      property,
+      isCompound: false
+    }];
+  }
+  const expanded = [];
+  for (const field of registeredType.expand) {
+    const expandedName = `${propertyName}${field.suffix}`;
+    const expandedProperty = {
+      type: "String",
+      // Use String as placeholder, actual SQL type is in field.sql
+      // Copy nullable from original property
+      ...property.nullable !== void 0 ? { nullable: property.nullable } : {}
+    };
+    expanded.push({
+      originalName: propertyName,
+      expandedName,
+      property: expandedProperty,
+      isCompound: true,
+      sourceType: typeName
+    });
+  }
+  return expanded;
+}
+function expandSchemaProperties(schema, registry) {
+  const expandedMap = /* @__PURE__ */ new Map();
+  if (!schema.properties) {
+    return expandedMap;
+  }
+  for (const [propName, property] of Object.entries(schema.properties)) {
+    const expanded = expandProperty(propName, property, registry);
+    expandedMap.set(propName, expanded);
+  }
+  return expandedMap;
+}
+function expandSchema(schema, registry) {
+  if (!schema.properties || schema.kind === "enum") {
+    return schema;
+  }
+  const expandedProperties = {};
+  let hasExpansion = false;
+  for (const [propName, property] of Object.entries(schema.properties)) {
+    const expanded = expandProperty(propName, property, registry);
+    const firstExpanded = expanded[0];
+    if (expanded.length === 1 && firstExpanded && !firstExpanded.isCompound) {
+      expandedProperties[propName] = property;
+    } else {
+      hasExpansion = true;
+      for (const exp of expanded) {
+        expandedProperties[exp.expandedName] = exp.property;
+      }
+    }
+  }
+  if (!hasExpansion) {
+    return schema;
+  }
+  return {
+    ...schema,
+    properties: expandedProperties
+  };
+}
+function expandSchemas(schemas, registry) {
+  const expanded = {};
+  for (const [name, schema] of Object.entries(schemas)) {
+    expanded[name] = expandSchema(schema, registry);
+  }
+  return expanded;
+}
+function getTypeInfo(typeName, registry) {
+  return registry.types.get(typeName);
+}
+function isCompoundType(typeName, registry) {
+  const type = registry.types.get(typeName);
+  return type?.compound === true;
+}
+function getCustomTypeNames(registry) {
+  return Array.from(registry.types.keys());
+}
+
+// src/api/omnify.ts
+var import_node_path = require("path");
+
+// src/api/metadata.ts
+function isAssociation(prop) {
+  return prop.type === "Association";
+}
+function getSchemaMetadata(schema) {
+  const propertyNames = [];
+  const associationNames = [];
+  if (schema.properties) {
+    for (const [name, prop] of Object.entries(schema.properties)) {
+      if (isAssociation(prop)) {
+        associationNames.push(name);
+      } else {
+        propertyNames.push(name);
+      }
+    }
+  }
+  const kind = schema.kind === "enum" ? "enum" : "entity";
+  const result = {
+    name: schema.name,
+    kind,
+    filePath: schema.filePath,
+    propertyNames,
+    associationNames,
+    hasTimestamps: schema.options?.timestamps ?? false,
+    hasSoftDelete: schema.options?.softDelete ?? false,
+    primaryKeyType: schema.options?.primaryKeyType ?? "Int"
+  };
+  if (schema.displayName !== void 0) {
+    result.displayName = schema.displayName;
+  }
+  if (schema.group !== void 0) {
+    result.group = schema.group;
+  }
+  return result;
+}
+function getPropertyMetadata(name, property, registry) {
+  if (isAssociation(property)) {
+    return {
+      name,
+      type: "Association",
+      nullable: false,
+      unique: false,
+      hasDefault: false,
+      isPluginType: false
+    };
+  }
+  const isPluginType = registry?.types.has(property.type) ?? false;
+  const pluginType = registry?.types.get(property.type);
+  const result = {
+    name,
+    type: property.type,
+    nullable: property.nullable ?? false,
+    unique: property.unique ?? false,
+    hasDefault: "default" in property && property.default !== void 0,
+    isPluginType
+  };
+  if ("default" in property && property.default !== void 0) {
+    result.defaultValue = property.default;
+  }
+  if (pluginType?.pluginName !== void 0) {
+    result.pluginName = pluginType.pluginName;
+  }
+  return result;
+}
+function getAssociationMetadata(name, association) {
+  const result = {
+    name,
+    relation: association.relation,
+    target: association.target
+  };
+  if (association.inversedBy !== void 0) {
+    result.inversedBy = association.inversedBy;
+  }
+  if (association.mappedBy !== void 0) {
+    result.mappedBy = association.mappedBy;
+  }
+  if (association.onDelete !== void 0) {
+    result.onDelete = association.onDelete;
+  }
+  if (association.onUpdate !== void 0) {
+    result.onUpdate = association.onUpdate;
+  }
+  return result;
+}
+function introspectSchema(schema, registry) {
+  const metadata = getSchemaMetadata(schema);
+  const properties = [];
+  const associations = [];
+  if (schema.properties) {
+    for (const [name, prop] of Object.entries(schema.properties)) {
+      if (isAssociation(prop)) {
+        associations.push(getAssociationMetadata(name, prop));
+      } else {
+        properties.push(getPropertyMetadata(name, prop, registry));
+      }
+    }
+  }
+  return {
+    metadata,
+    properties,
+    associations,
+    schema
+  };
+}
+function introspectSchemas(schemas, registry) {
+  const result = /* @__PURE__ */ new Map();
+  for (const [name, schema] of Object.entries(schemas)) {
+    result.set(name, introspectSchema(schema, registry));
+  }
+  return result;
+}
+function getSchemaNames(schemas) {
+  return Object.keys(schemas);
+}
+function getSchemasByKind(schemas, kind) {
+  return Object.values(schemas).filter((schema) => {
+    const schemaKind = schema.kind === "enum" ? "enum" : "entity";
+    return schemaKind === kind;
+  });
+}
+function getEntitySchemas(schemas) {
+  return getSchemasByKind(schemas, "entity");
+}
+function getEnumSchemas(schemas) {
+  return getSchemasByKind(schemas, "enum");
+}
+function getSchemasByGroup(schemas, group) {
+  return Object.values(schemas).filter((schema) => schema.group === group);
+}
+function getGroups(schemas) {
+  const groups = /* @__PURE__ */ new Set();
+  for (const schema of Object.values(schemas)) {
+    if (schema.group) {
+      groups.add(schema.group);
+    }
+  }
+  return Array.from(groups).sort();
+}
+function getSchemaAssociations(schema) {
+  if (!schema.properties) return [];
+  const associations = [];
+  for (const prop of Object.values(schema.properties)) {
+    if (isAssociation(prop)) {
+      associations.push(prop);
+    }
+  }
+  return associations;
+}
+function findReferencingSchemas(schemas, targetName) {
+  const result = [];
+  for (const schema of Object.values(schemas)) {
+    const associations = getSchemaAssociations(schema);
+    for (const association of associations) {
+      if (association.target === targetName) {
+        result.push(schema);
+        break;
+      }
+    }
+  }
+  return result;
+}
+function findReferencedSchemas(schemas, sourceName) {
+  const source = schemas[sourceName];
+  if (!source) return [];
+  const associations = getSchemaAssociations(source);
+  const targetNames = new Set(associations.map((a) => a.target));
+  return Object.values(schemas).filter((s) => targetNames.has(s.name));
+}
+function getRelationshipGraph(schemas) {
+  const graph = /* @__PURE__ */ new Map();
+  for (const schema of Object.values(schemas)) {
+    const targets = [];
+    const associations = getSchemaAssociations(schema);
+    for (const association of associations) {
+      if (!targets.includes(association.target)) {
+        targets.push(association.target);
+      }
+    }
+    graph.set(schema.name, targets);
+  }
+  return graph;
+}
+function hasCircularReferences(schemas) {
+  const graph = getRelationshipGraph(schemas);
+  const visited = /* @__PURE__ */ new Set();
+  const recursionStack = /* @__PURE__ */ new Set();
+  function hasCycle(node) {
+    if (recursionStack.has(node)) return true;
+    if (visited.has(node)) return false;
+    visited.add(node);
+    recursionStack.add(node);
+    const neighbors = graph.get(node) ?? [];
+    for (const neighbor of neighbors) {
+      if (hasCycle(neighbor)) return true;
+    }
+    recursionStack.delete(node);
+    return false;
+  }
+  for (const schemaName of graph.keys()) {
+    if (hasCycle(schemaName)) return true;
+  }
+  return false;
+}
+function getTopologicalOrder(schemas) {
+  const graph = getRelationshipGraph(schemas);
+  const result = [];
+  const visited = /* @__PURE__ */ new Set();
+  function visit(node) {
+    if (visited.has(node)) return;
+    visited.add(node);
+    const neighbors = graph.get(node) ?? [];
+    for (const neighbor of neighbors) {
+      visit(neighbor);
+    }
+    result.push(node);
+  }
+  for (const schemaName of graph.keys()) {
+    visit(schemaName);
+  }
+  return result.reverse();
+}
+
+// src/api/omnify.ts
+var nullLogger2 = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+};
+var consoleLogger2 = {
+  debug: (msg, ...args) => console.debug(`[omnify] ${msg}`, ...args),
+  info: (msg, ...args) => console.info(`[omnify] ${msg}`, ...args),
+  warn: (msg, ...args) => console.warn(`[omnify] ${msg}`, ...args),
+  error: (msg, ...args) => console.error(`[omnify] ${msg}`, ...args)
+};
+var Omnify = class {
+  options;
+  logger;
+  pluginManager;
+  schemas = null;
+  loaded = false;
+  constructor(options) {
+    this.options = {
+      ...options,
+      schemaDir: (0, import_node_path.resolve)(options.schemaDir)
+    };
+    this.logger = options.logger ?? (options.verbose ? consoleLogger2 : nullLogger2);
+    this.pluginManager = createPluginManager({ logger: this.logger });
+  }
+  /**
+   * Registers plugins with the plugin manager.
+   */
+  async registerPlugins(plugins) {
+    for (const plugin of plugins) {
+      this.logger.debug(`Registering plugin: ${plugin.name}`);
+      const result = await this.pluginManager.register(plugin);
+      if (!result.success) {
+        throw new Error(`Failed to register plugin ${plugin.name}: ${result.error}`);
+      }
+      if (result.warnings.length > 0) {
+        for (const warning of result.warnings) {
+          this.logger.warn(warning);
+        }
+      }
+    }
+  }
+  /**
+   * Loads and validates schemas from the configured directory.
+   */
+  async load() {
+    this.logger.info(`Loading schemas from: ${this.options.schemaDir}`);
+    if (this.options.plugins?.length) {
+      await this.registerPlugins(this.options.plugins);
+    }
+    const errors = [];
+    const warnings = [];
+    try {
+      const schemas = await loadSchemas(this.options.schemaDir, {
+        recursive: true
+      });
+      this.logger.debug(`Loaded ${Object.keys(schemas).length} schemas`);
+      const customTypeNames = Array.from(this.pluginManager.getRegistry().types.keys());
+      const validationResult = validateSchemas(schemas, {
+        customTypes: customTypeNames
+      });
+      for (const error of validationResult.errors) {
+        const schemaError = {
+          file: error.file ?? "unknown",
+          message: error.message
+        };
+        if (error.line !== void 0) {
+          schemaError.line = error.line;
+        }
+        if (error.suggestion !== void 0) {
+          schemaError.suggestion = error.suggestion;
+        }
+        errors.push(schemaError);
+      }
+      for (const warning of validationResult.warnings) {
+        warnings.push({
+          file: warning.file ?? "unknown",
+          message: warning.message
+        });
+      }
+      if (validationResult.valid) {
+        this.schemas = schemas;
+        this.loaded = true;
+      }
+      return {
+        success: validationResult.valid,
+        schemas,
+        errors,
+        warnings
+      };
+    } catch (error) {
+      if (error instanceof OmnifyError) {
+        const schemaError = {
+          file: error.file ?? "unknown",
+          message: error.message
+        };
+        if (error.line !== void 0) {
+          schemaError.line = error.line;
+        }
+        if (error.suggestion !== void 0) {
+          schemaError.suggestion = error.suggestion;
+        }
+        errors.push(schemaError);
+      } else {
+        errors.push({
+          file: "unknown",
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }
+      return {
+        success: false,
+        schemas: {},
+        errors,
+        warnings
+      };
+    }
+  }
+  /**
+   * Gets loaded schemas. Throws if not loaded.
+   */
+  getSchemas() {
+    if (!this.loaded || !this.schemas) {
+      throw new Error("Schemas not loaded. Call load() first.");
+    }
+    return this.schemas;
+  }
+  /**
+   * Gets a single schema by name.
+   */
+  getSchema(name) {
+    const schemas = this.getSchemas();
+    const schema = schemas[name];
+    if (!schema) return void 0;
+    return introspectSchema(schema, this.pluginManager.getRegistry());
+  }
+  /**
+   * Gets all schema names.
+   */
+  getSchemaNames() {
+    return getSchemaNames(this.getSchemas());
+  }
+  /**
+   * Gets entity schemas (non-enum).
+   */
+  getEntitySchemas() {
+    const schemas = getEntitySchemas(this.getSchemas());
+    return schemas.map(
+      (s) => introspectSchema(s, this.pluginManager.getRegistry())
+    );
+  }
+  /**
+   * Gets enum schemas.
+   */
+  getEnumSchemas() {
+    const schemas = getEnumSchemas(this.getSchemas());
+    return schemas.map(
+      (s) => introspectSchema(s, this.pluginManager.getRegistry())
+    );
+  }
+  /**
+   * Gets schemas by group.
+   */
+  getSchemasByGroup(group) {
+    const schemas = getSchemasByGroup(this.getSchemas(), group);
+    return schemas.map(
+      (s) => introspectSchema(s, this.pluginManager.getRegistry())
+    );
+  }
+  /**
+   * Gets all unique group names.
+   */
+  getGroups() {
+    return getGroups(this.getSchemas());
+  }
+  /**
+   * Introspects a specific schema.
+   */
+  introspect(name) {
+    return this.getSchema(name);
+  }
+  /**
+   * Introspects all schemas.
+   */
+  introspectAll() {
+    return introspectSchemas(this.getSchemas(), this.pluginManager.getRegistry());
+  }
+  /**
+   * Finds schemas that reference a target schema.
+   */
+  findReferencingSchemas(targetName) {
+    const schemas = findReferencingSchemas(this.getSchemas(), targetName);
+    return schemas.map(
+      (s) => introspectSchema(s, this.pluginManager.getRegistry())
+    );
+  }
+  /**
+   * Finds schemas referenced by a source schema.
+   */
+  findReferencedSchemas(sourceName) {
+    const schemas = findReferencedSchemas(this.getSchemas(), sourceName);
+    return schemas.map(
+      (s) => introspectSchema(s, this.pluginManager.getRegistry())
+    );
+  }
+  /**
+   * Checks if schemas have circular references.
+   */
+  hasCircularReferences() {
+    return hasCircularReferences(this.getSchemas());
+  }
+  /**
+   * Gets topological order of schemas (dependencies first).
+   */
+  getTopologicalOrder() {
+    return getTopologicalOrder(this.getSchemas());
+  }
+  /**
+   * Gets the plugin registry.
+   */
+  getPluginRegistry() {
+    return this.pluginManager.getRegistry();
+  }
+  /**
+   * Checks if a type is registered (from plugin).
+   */
+  hasType(typeName) {
+    return this.pluginManager.hasType(typeName);
+  }
+  /**
+   * Gets custom type names from all registered plugins.
+   */
+  getCustomTypeNames() {
+    return Array.from(this.pluginManager.getRegistry().types.keys());
+  }
+};
+function createOmnify(options) {
+  return new Omnify(options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Omnify,
+  OmnifyError,
+  PluginManager,
+  atlasError,
+  atlasNotFoundError,
+  circularReferenceError,
+  configError,
+  configNotFoundError,
+  createOmnify,
+  createPluginManager,
+  duplicateSchemaError,
+  err,
+  expandProperty,
+  expandSchema,
+  expandSchemaProperties,
+  expandSchemas,
+  fileNameToSchemaName,
+  findReferencedSchemas,
+  findReferencingSchemas,
+  formatError,
+  formatErrorPlain,
+  formatErrorSummary,
+  generationError,
+  getAssociationMetadata,
+  getCustomTypeNames,
+  getEntitySchemas,
+  getEnumSchemas,
+  getExitCode,
+  getGroups,
+  getPropertyMetadata,
+  getRelationshipGraph,
+  getSchemaMetadata,
+  getSchemaNames,
+  getSchemasByGroup,
+  getSchemasByKind,
+  getTopologicalOrder,
+  getTypeInfo,
+  hasCircularReferences,
+  internalError,
+  introspectSchema,
+  introspectSchemas,
+  invalidAssociationTargetError,
+  invalidConfigError,
+  invalidPropertyTypeError,
+  isCompoundType,
+  jsonSyntaxError,
+  loadSchema,
+  loadSchemas,
+  missingConfigFieldError,
+  missingFieldError,
+  notImplementedError,
+  ok,
+  outputWriteError,
+  parseJsonSchema,
+  parseYamlSchema,
+  pluginError,
+  pluginNotFoundError,
+  pluginTypeConflictError,
+  schemaNotFoundError,
+  schemaParseError,
+  validateAssociations,
+  validateEnumSchema,
+  validateOptions,
+  validateProperties,
+  validatePropertyType,
+  validateSchema,
+  validateSchemas,
+  validationError,
+  yamlSyntaxError
+});
+//# sourceMappingURL=index.cjs.map