@happyvertical/smrt-core 0.30.0

package/dist/registry/name-resolver.js

@@ -0,0 +1,241 @@
+import { ConfigurationError } from "../errors.js";
+import { isQualifiedName, parseQualifiedName, createQualifiedName } from "../utils/qualified-names.js";
+import { getClasses, verboseLog, getConstructorIndex } from "./shared-state.js";
+function registryKeysBySimpleName(simpleName) {
+  const lower = simpleName.toLowerCase();
+  const classes = getClasses();
+  const seen = /* @__PURE__ */ new Map();
+  for (const [key, value] of classes.entries()) {
+    if (value.name?.toLowerCase() !== lower) continue;
+    const existing = seen.get(value);
+    if (!existing) {
+      seen.set(value, key);
+      continue;
+    }
+    if (key.includes(":") && !existing.includes(":")) {
+      seen.set(value, key);
+    }
+  }
+  return [...seen.values()];
+}
+function getCanonicalClassName(name) {
+  const keys = registryKeysBySimpleName(name);
+  if (keys.length === 1) return keys[0];
+  return void 0;
+}
+function hasClassCaseInsensitive(name) {
+  const lower = name.toLowerCase();
+  for (const value of getClasses().values()) {
+    if (value.name?.toLowerCase() === lower) return true;
+  }
+  return false;
+}
+function findClass(name) {
+  const classes = getClasses();
+  const registered = classes.get(name);
+  if (registered) {
+    return registered;
+  }
+  if (isQualifiedName(name)) {
+    const { packageName, className } = parseQualifiedName(name);
+    const keys2 = registryKeysBySimpleName(className);
+    if (keys2.length > 0) {
+      const exactPackageMatch = keys2.map((key) => classes.get(key)).find((candidate) => candidate?.packageName === packageName);
+      if (exactPackageMatch) {
+        return exactPackageMatch;
+      }
+      if (keys2.length === 1) {
+        const fallback = classes.get(keys2[0]);
+        if (fallback && !fallback.packageName) {
+          return fallback;
+        }
+      }
+    }
+    return void 0;
+  }
+  const keys = registryKeysBySimpleName(name);
+  if (keys.length > 0) {
+    if (keys.length === 1) {
+      return classes.get(keys[0]);
+    }
+    verboseLog(
+      `[registry] findClass("${name}") is ambiguous — ${keys.length} matches. Use qualified name (e.g., ${keys[0]}) for precision.`
+    );
+    return classes.get(keys[0]);
+  }
+  return void 0;
+}
+function findClassStrict(name, fromPackage) {
+  const classes = getClasses();
+  const registered = classes.get(name);
+  if (registered) {
+    return registered;
+  }
+  if (isQualifiedName(name)) {
+    return void 0;
+  }
+  if (fromPackage) {
+    const qualifiedAttempt = createQualifiedName(fromPackage, name);
+    const byQualified = classes.get(qualifiedAttempt);
+    if (byQualified) {
+      return byQualified;
+    }
+  }
+  const keys = registryKeysBySimpleName(name);
+  if (keys.length > 0) {
+    if (keys.length === 1) {
+      return classes.get(keys[0]);
+    }
+    throw new ConfigurationError(
+      `Ambiguous class name "${name}" — found in ${keys.length} packages: ${keys.join(", ")}. Use a qualified name (e.g., ${keys[0]}) to disambiguate.`,
+      "CONFIG_AMBIGUOUS_CLASS",
+      { className: name, candidates: keys }
+    );
+  }
+  return void 0;
+}
+function qualifyExtendsName(extendsValue, currentPackage) {
+  const classes = getClasses();
+  if (isQualifiedName(extendsValue)) {
+    return extendsValue;
+  }
+  if (extendsValue === "SmrtObject" || extendsValue === "SmrtClass" || extendsValue === "SmrtCollection") {
+    return extendsValue;
+  }
+  const samePackageQualified = createQualifiedName(
+    currentPackage,
+    extendsValue
+  );
+  if (classes.has(samePackageQualified)) {
+    return samePackageQualified;
+  }
+  const keys = registryKeysBySimpleName(extendsValue);
+  if (keys.length === 1) {
+    return keys[0];
+  }
+  return extendsValue;
+}
+function getClass(name) {
+  return findClass(name);
+}
+function getClassByConstructor(ctor) {
+  const registeredName = getConstructorIndex().get(ctor);
+  if (registeredName) {
+    return getClasses().get(registeredName);
+  }
+  return void 0;
+}
+function getClassByQualifiedName(qualifiedName) {
+  return getClasses().get(qualifiedName);
+}
+function getClassInPackage(packageName, className) {
+  const qualifiedName = createQualifiedName(packageName, className);
+  return getClasses().get(qualifiedName);
+}
+function findClassesByName(className) {
+  const matches = [];
+  const lowerName = className.toLowerCase();
+  for (const registered of getClasses().values()) {
+    if (registered.name.toLowerCase() === lowerName) {
+      matches.push(registered);
+    }
+  }
+  return matches;
+}
+function resolveType(shortName) {
+  if (shortName.includes(":") && shortName.startsWith("@")) {
+    const registered = getClassByQualifiedName(shortName);
+    if (!registered) {
+      throw new Error(
+        `Class "${shortName}" is not registered. Make sure the package is installed and the class is decorated with @smrt().`
+      );
+    }
+    return shortName;
+  }
+  const matches = findClassesByName(shortName);
+  if (matches.length === 0) {
+    throw new Error(
+      `Class "${shortName}" is not registered. Make sure the package is installed and the class is decorated with @smrt().`
+    );
+  }
+  if (matches.length > 1) {
+    const packageList = matches.map((m) => `  - ${m.qualifiedName}`).join("\n");
+    throw new Error(
+      `"${shortName}" is ambiguous. Found in multiple packages:
+${packageList}
+Use the fully qualified name instead.`
+    );
+  }
+  return matches[0].qualifiedName;
+}
+function getClassesByPackage(packageName) {
+  const result = /* @__PURE__ */ new Map();
+  for (const [name, registered] of getClasses().entries()) {
+    if (registered.packageName === packageName) {
+      result.set(name, registered);
+    }
+  }
+  return result;
+}
+function getClassesByVisibility(visibility) {
+  const result = /* @__PURE__ */ new Map();
+  for (const [name, registered] of getClasses().entries()) {
+    const classVisibility = registered.visibility || "public";
+    if (classVisibility === visibility) {
+      result.set(name, registered);
+    }
+  }
+  return result;
+}
+function getPublicClasses() {
+  return getClassesByVisibility("public");
+}
+function getAllClasses() {
+  return new Map(getClasses());
+}
+function getClassNames() {
+  const names = Array.from(getClasses().values()).map((entry) => entry.name);
+  return Array.from(new Set(names));
+}
+function getQualifiedClassNames() {
+  const names = [];
+  const seenRegistrations = /* @__PURE__ */ new Set();
+  const seenNames = /* @__PURE__ */ new Set();
+  for (const [key, entry] of getClasses().entries()) {
+    if (seenRegistrations.has(entry)) {
+      continue;
+    }
+    seenRegistrations.add(entry);
+    const lookupName = entry.qualifiedName || key || entry.name;
+    if (seenNames.has(lookupName)) {
+      continue;
+    }
+    seenNames.add(lookupName);
+    names.push(lookupName);
+  }
+  return names;
+}
+function hasClass(name) {
+  return findClass(name) !== void 0;
+}
+export {
+  findClass,
+  findClassStrict,
+  findClassesByName,
+  getAllClasses,
+  getCanonicalClassName,
+  getClass,
+  getClassByConstructor,
+  getClassByQualifiedName,
+  getClassInPackage,
+  getClassNames,
+  getClassesByPackage,
+  getClassesByVisibility,
+  getPublicClasses,
+  getQualifiedClassNames,
+  hasClass,
+  hasClassCaseInsensitive,
+  qualifyExtendsName,
+  resolveType
+};
+//# sourceMappingURL=name-resolver.js.map

package/dist/registry/name-resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"name-resolver.js","sources":["../../src/registry/name-resolver.ts"],"sourcesContent":["/**\n * Name resolution module for the SMRT ObjectRegistry.\n *\n * Handles class lookup, disambiguation, and qualified name resolution.\n * All functions operate on the shared globalThis state.\n *\n * Release B (#1133): classNameMap is gone — the eagerly-maintained\n * lowercase-simple-name → qualified-key[] index was removed in favor of\n * on-demand iteration over the `classes` Map. Production SMRT apps carry\n * a few hundred classes at most, so the linear scan is negligible and\n * removes an entire class of cache-sync bugs (#584, #847, #951).\n *\n * Extracted from registry.ts as part of issue #1006.\n * @see https://github.com/happyvertical/smrt/issues/1006\n * @see https://github.com/happyvertical/smrt/issues/1133\n */\n\nimport { ConfigurationError } from '../errors';\nimport type { QualifiedClassName, SmrtVisibility } from '../scanner/types.js';\nimport {\n  createQualifiedName,\n  isQualifiedName,\n  parseQualifiedName,\n} from '../utils/qualified-names.js';\nimport { getClasses, getConstructorIndex, verboseLog } from './shared-state';\nimport type { RegisteredClass, SmrtObjectConstructor } from './types';\n\n// ── Simple-name iteration (replaces classNameMap reads) ─────────────\n\n/**\n * Return every registry key whose registered class has the given simple\n * name (case-insensitive). Replaces the old eagerly-maintained\n * `__smrtRegistryClassNameMap` lookup: we iterate `classes` instead.\n *\n * Cost is O(n) over the classes map; production SMRT apps hold low-\n * hundreds of entries so this is trivially fast. Returned keys preserve\n * insertion order, which makes the \"first match wins\" behavior of the old\n * map-based lookup deterministic in the same way.\n *\n * De-duplicates by RegisteredClass object identity so a class registered\n * under both a simple key and a promoted qualified key (a transitional\n * state during manifest merge) counts as a single entry — matching the\n * old classNameMap's behavior of storing each canonical qualified key once.\n * When that happens, the qualified key wins over the simple one.\n */\nfunction registryKeysBySimpleName(simpleName: string): string[] {\n  const lower = simpleName.toLowerCase();\n  const classes = getClasses();\n  const seen = new Map<unknown, string>();\n\n  for (const [key, value] of classes.entries()) {\n    if (value.name?.toLowerCase() !== lower) continue;\n\n    const existing = seen.get(value);\n    if (!existing) {\n      seen.set(value, key);\n      continue;\n    }\n\n    // Two keys for the same object: prefer the qualified form.\n    if (key.includes(':') && !existing.includes(':')) {\n      seen.set(value, key);\n    }\n  }\n\n  return [...seen.values()];\n}\n\n// ── Lookup functions ────────────────────────────────────────\n\n/**\n * Check if a class is already registered (case-insensitive).\n * Returns the canonical name if found, undefined otherwise. Returns\n * undefined if the simple name is ambiguous across multiple packages.\n */\nexport function getCanonicalClassName(name: string): string | undefined {\n  const keys = registryKeysBySimpleName(name);\n  if (keys.length === 1) return keys[0];\n  // Zero matches, or ambiguous with >1 entries\n  return undefined;\n}\n\n/**\n * Check if a class exists by name (case-insensitive).\n */\nexport function hasClassCaseInsensitive(name: string): boolean {\n  const lower = name.toLowerCase();\n  for (const value of getClasses().values()) {\n    if (value.name?.toLowerCase() === lower) return true;\n  }\n  return false;\n}\n\n/**\n * Helper for class lookup with qualified name support.\n *\n * Lookup priority:\n * 1. Direct hit on classes map (works for qualified names as keys)\n * 2. If input contains ':', prefer direct qualified lookup, then fall back\n *    to an exact/simple registration when runtime source imports registered\n *    the class before package-qualified promotion happened\n * 3. Simple-name iteration by lowercase\n *    - Unambiguous (1 match) → return it\n *    - Ambiguous (>1 matches) → log warning, return first\n */\nexport function findClass(name: string): RegisteredClass | undefined {\n  const classes = getClasses();\n\n  // 1. Direct hit on classes map (fast path, works for qualified keys)\n  const registered = classes.get(name);\n  if (registered) {\n    return registered;\n  }\n\n  // 2. Qualified lookup fallback for source-registered classes.\n  // In workspace/dev mode a package can be imported from source before a\n  // manifest-promoted qualified key exists. If we already have exactly the\n  // requested package or a single unqualified registration for this class\n  // name, treat it as the same class instead of forcing node_modules manifest\n  // discovery.\n  if (isQualifiedName(name)) {\n    const { packageName, className } = parseQualifiedName(name);\n    const keys = registryKeysBySimpleName(className);\n\n    if (keys.length > 0) {\n      const exactPackageMatch = keys\n        .map((key) => classes.get(key))\n        .find((candidate) => candidate?.packageName === packageName);\n\n      if (exactPackageMatch) {\n        return exactPackageMatch;\n      }\n\n      if (keys.length === 1) {\n        const fallback = classes.get(keys[0]);\n        if (fallback && !fallback.packageName) {\n          return fallback;\n        }\n      }\n    }\n\n    return undefined;\n  }\n\n  // 3. Simple-name lookup\n  const keys = registryKeysBySimpleName(name);\n  if (keys.length > 0) {\n    if (keys.length === 1) {\n      return classes.get(keys[0]);\n    }\n    // Ambiguous — multiple packages define this class name\n    // Return first match but log a warning (use resolveType() for strict behavior)\n    verboseLog(\n      `[registry] findClass(\"${name}\") is ambiguous — ${keys.length} matches. ` +\n        `Use qualified name (e.g., ${keys[0]}) for precision.`,\n    );\n    return classes.get(keys[0]);\n  }\n\n  return undefined;\n}\n\n/**\n * Strict class lookup with package-aware disambiguation.\n *\n * Unlike `findClass()` which silently returns the first match when a simple\n * name is ambiguous, this method throws a `ConfigurationError` — making it\n * safe for inheritance-critical paths.\n *\n * @throws {ConfigurationError} When simple name is ambiguous and no package context resolves it\n * @see https://github.com/happyvertical/smrt/issues/1005\n */\nexport function findClassStrict(\n  name: string,\n  fromPackage?: string,\n): RegisteredClass | undefined {\n  const classes = getClasses();\n\n  // 1. Direct hit on classes map (fast path, works for qualified keys)\n  const registered = classes.get(name);\n  if (registered) {\n    return registered;\n  }\n\n  // 2. If input is a qualified name, no fallback — it's not found\n  if (isQualifiedName(name)) {\n    return undefined;\n  }\n\n  // 3. If fromPackage provided, try constructing qualified name for direct lookup\n  if (fromPackage) {\n    const qualifiedAttempt = createQualifiedName(fromPackage, name);\n    const byQualified = classes.get(qualifiedAttempt);\n    if (byQualified) {\n      return byQualified;\n    }\n  }\n\n  // 4. Simple-name lookup\n  const keys = registryKeysBySimpleName(name);\n  if (keys.length > 0) {\n    if (keys.length === 1) {\n      return classes.get(keys[0]);\n    }\n    // Ambiguous — multiple packages define this class name\n    // In strict mode, throw instead of silently returning first match\n    throw new ConfigurationError(\n      `Ambiguous class name \"${name}\" — found in ${keys.length} packages: ` +\n        `${keys.join(', ')}. ` +\n        `Use a qualified name (e.g., ${keys[0]}) to disambiguate.`,\n      'CONFIG_AMBIGUOUS_CLASS',\n      { className: name, candidates: keys },\n    );\n  }\n\n  return undefined;\n}\n\n/**\n * Qualify an `extends` value with the parent class's package name.\n *\n * @see https://github.com/happyvertical/smrt/issues/1004\n */\nexport function qualifyExtendsName(\n  extendsValue: string,\n  currentPackage: string,\n): string {\n  const classes = getClasses();\n\n  // Already qualified → pass through\n  if (isQualifiedName(extendsValue)) {\n    return extendsValue;\n  }\n\n  // Skip framework base classes (never registered with qualified names)\n  if (\n    extendsValue === 'SmrtObject' ||\n    extendsValue === 'SmrtClass' ||\n    extendsValue === 'SmrtCollection'\n  ) {\n    return extendsValue;\n  }\n\n  // Try same-package first (common case: child and parent in same package)\n  const samePackageQualified = createQualifiedName(\n    currentPackage,\n    extendsValue,\n  );\n  if (classes.has(samePackageQualified)) {\n    return samePackageQualified;\n  }\n\n  // Try to find the parent in any registered package\n  const keys = registryKeysBySimpleName(extendsValue);\n  if (keys.length === 1) {\n    return keys[0];\n  }\n\n  // Fallback: return unmodified (backward compat)\n  return extendsValue;\n}\n\n// ── Public lookup functions ─────────────────────────────────\n\n/**\n * Get a registered class by name (case-insensitive).\n */\nexport function getClass(name: string): RegisteredClass | undefined {\n  return findClass(name);\n}\n\n/**\n * Get a registered class by its constructor reference (O(1) WeakMap lookup).\n */\nexport function getClassByConstructor(\n  ctor: SmrtObjectConstructor,\n): RegisteredClass | undefined {\n  const registeredName = getConstructorIndex().get(ctor);\n  if (registeredName) {\n    return getClasses().get(registeredName);\n  }\n  return undefined;\n}\n\n/**\n * Get a registered class by its qualified name (O(1) direct lookup).\n */\nexport function getClassByQualifiedName(\n  qualifiedName: string,\n): RegisteredClass | undefined {\n  return getClasses().get(qualifiedName);\n}\n\n/**\n * Get a registered class by package name and class name.\n */\nexport function getClassInPackage(\n  packageName: string,\n  className: string,\n): RegisteredClass | undefined {\n  const qualifiedName = createQualifiedName(packageName, className);\n  return getClasses().get(qualifiedName);\n}\n\n/**\n * Find all registered classes with a given simple class name.\n */\nexport function findClassesByName(className: string): RegisteredClass[] {\n  const matches: RegisteredClass[] = [];\n  const lowerName = className.toLowerCase();\n\n  for (const registered of getClasses().values()) {\n    if (registered.name.toLowerCase() === lowerName) {\n      matches.push(registered);\n    }\n  }\n\n  return matches;\n}\n\n/**\n * Resolve a short class name to its qualified name.\n * @throws {Error} If no class or ambiguous classes registered\n */\nexport function resolveType(shortName: string): QualifiedClassName {\n  // If already qualified, validate and return\n  if (shortName.includes(':') && shortName.startsWith('@')) {\n    const registered = getClassByQualifiedName(shortName as QualifiedClassName);\n    if (!registered) {\n      throw new Error(\n        `Class \"${shortName}\" is not registered. ` +\n          `Make sure the package is installed and the class is decorated with @smrt().`,\n      );\n    }\n    return shortName as QualifiedClassName;\n  }\n\n  // Find all classes with this short name\n  const matches = findClassesByName(shortName);\n\n  if (matches.length === 0) {\n    throw new Error(\n      `Class \"${shortName}\" is not registered. ` +\n        `Make sure the package is installed and the class is decorated with @smrt().`,\n    );\n  }\n\n  if (matches.length > 1) {\n    const packageList = matches.map((m) => `  - ${m.qualifiedName}`).join('\\n');\n    throw new Error(\n      `\"${shortName}\" is ambiguous. Found in multiple packages:\\n${packageList}\\n` +\n        `Use the fully qualified name instead.`,\n    );\n  }\n\n  return matches[0].qualifiedName as QualifiedClassName;\n}\n\n/**\n * Get all registered classes from a specific package.\n */\nexport function getClassesByPackage(\n  packageName: string,\n): Map<string, RegisteredClass> {\n  const result = new Map<string, RegisteredClass>();\n\n  for (const [name, registered] of getClasses().entries()) {\n    if (registered.packageName === packageName) {\n      result.set(name, registered);\n    }\n  }\n\n  return result;\n}\n\n/**\n * Get all registered classes with a specific visibility level.\n */\nexport function getClassesByVisibility(\n  visibility: SmrtVisibility,\n): Map<string, RegisteredClass> {\n  const result = new Map<string, RegisteredClass>();\n\n  for (const [name, registered] of getClasses().entries()) {\n    const classVisibility = registered.visibility || 'public';\n    if (classVisibility === visibility) {\n      result.set(name, registered);\n    }\n  }\n\n  return result;\n}\n\n/**\n * Get all public registered classes.\n */\nexport function getPublicClasses(): Map<string, RegisteredClass> {\n  return getClassesByVisibility('public');\n}\n\n/**\n * Get all registered classes.\n */\nexport function getAllClasses(): Map<string, RegisteredClass> {\n  return new Map(getClasses());\n}\n\n/**\n * Get class names (simple names, deduplicated).\n */\nexport function getClassNames(): string[] {\n  const names = Array.from(getClasses().values()).map((entry) => entry.name);\n  return Array.from(new Set(names));\n}\n\n/**\n * Get lookup names for every registered class without collapsing\n * cross-package simple-name collisions.\n *\n * Prefer each registration's qualified name when available, fall back to the\n * registry key, then to the simple class name for package-less registrations.\n * De-duplicates aliases that point to the same RegisteredClass object while\n * preserving distinct packages that intentionally share a simple class name.\n */\nexport function getQualifiedClassNames(): string[] {\n  const names: string[] = [];\n  const seenRegistrations = new Set<RegisteredClass>();\n  const seenNames = new Set<string>();\n\n  for (const [key, entry] of getClasses().entries()) {\n    if (seenRegistrations.has(entry)) {\n      continue;\n    }\n    seenRegistrations.add(entry);\n\n    const lookupName = entry.qualifiedName || key || entry.name;\n    if (seenNames.has(lookupName)) {\n      continue;\n    }\n\n    seenNames.add(lookupName);\n    names.push(lookupName);\n  }\n\n  return names;\n}\n\n/**\n * Check if a class is registered (case-insensitive).\n */\nexport function hasClass(name: string): boolean {\n  return findClass(name) !== undefined;\n}\n"],"names":["keys"],"mappings":"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"}

package/dist/registry/relationship-graph.d.ts

@@ -0,0 +1,16 @@
+import { RelationshipMetadata } from './types';
+/**
+ * Build dependency graph from foreignKey relationships.
+ *
+ * Returns a map where keys are class names and values are arrays
+ * of class names that the key depends on (via foreignKey fields).
+ */
+export declare function getDependencyGraph(): Map<string, string[]>;
+/**
+ * Build comprehensive relationship map from all field types.
+ *
+ * Returns a map containing all relationships (foreignKey, oneToMany, manyToMany)
+ * discovered in registered classes.
+ */
+export declare function getRelationshipMap(): Map<string, RelationshipMetadata[]>;
+//# sourceMappingURL=relationship-graph.d.ts.map

package/dist/registry/relationship-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relationship-graph.d.ts","sourceRoot":"","sources":["../../src/registry/relationship-graph.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEpD;;;;;GAKG;AACH,wBAAgB,kBAAkB,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAgC1D;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,IAAI,GAAG,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAC,CAgExE"}

package/dist/registry/relationship-graph.js

@@ -0,0 +1,79 @@
+import { findClass } from "./name-resolver.js";
+import { getClasses } from "./shared-state.js";
+function getDependencyGraph() {
+  const classes = getClasses();
+  const graph = /* @__PURE__ */ new Map();
+  for (const [_key, entry] of classes) {
+    graph.set(entry.name || _key, []);
+  }
+  for (const [_key, registered] of classes) {
+    const simpleName = registered.name || _key;
+    const dependencies = [];
+    for (const [_fieldName, field] of registered.fields) {
+      if (field.type === "foreignKey" && field.related) {
+        const relatedClass = field.related;
+        if (relatedClass !== simpleName && findClass(relatedClass) !== void 0) {
+          dependencies.push(relatedClass);
+        }
+      }
+    }
+    graph.set(simpleName, dependencies);
+  }
+  return graph;
+}
+function getRelationshipMap() {
+  const classes = getClasses();
+  const relationshipMap = /* @__PURE__ */ new Map();
+  for (const [_key, entry] of classes) {
+    relationshipMap.set(entry.name || _key, []);
+  }
+  for (const [_key, registered] of classes) {
+    const simpleName = registered.name || _key;
+    const relationships = [];
+    for (const [fieldName, field] of registered.fields) {
+      if (field.type === "foreignKey" && field.related) {
+        relationships.push({
+          sourceClass: simpleName,
+          fieldName,
+          targetClass: field.related,
+          type: "foreignKey",
+          options: field._meta
+        });
+      }
+      if (field.type === "crossPackageRef" && field.related) {
+        relationships.push({
+          sourceClass: simpleName,
+          fieldName,
+          targetClass: field.related,
+          type: "crossPackageRef",
+          options: field._meta
+        });
+      }
+      if (field.type === "oneToMany" && field.related) {
+        relationships.push({
+          sourceClass: simpleName,
+          fieldName,
+          targetClass: field.related,
+          type: "oneToMany",
+          options: field._meta
+        });
+      }
+      if (field.type === "manyToMany" && field.related) {
+        relationships.push({
+          sourceClass: simpleName,
+          fieldName,
+          targetClass: field.related,
+          type: "manyToMany",
+          options: field._meta
+        });
+      }
+    }
+    relationshipMap.set(simpleName, relationships);
+  }
+  return relationshipMap;
+}
+export {
+  getDependencyGraph,
+  getRelationshipMap
+};
+//# sourceMappingURL=relationship-graph.js.map

package/dist/registry/relationship-graph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relationship-graph.js","sources":["../../src/registry/relationship-graph.ts"],"sourcesContent":["/**\n * Relationship graph and dependency resolution module for the SMRT ObjectRegistry.\n *\n * Builds relationship maps and dependency graphs from registered class fields.\n *\n * Extracted from registry.ts as part of issue #1006.\n * @see https://github.com/happyvertical/smrt/issues/1006\n */\n\nimport { findClass } from './name-resolver';\nimport { getClasses } from './shared-state';\nimport type { RelationshipMetadata } from './types';\n\n/**\n * Build dependency graph from foreignKey relationships.\n *\n * Returns a map where keys are class names and values are arrays\n * of class names that the key depends on (via foreignKey fields).\n */\nexport function getDependencyGraph(): Map<string, string[]> {\n  const classes = getClasses();\n  const graph = new Map<string, string[]>();\n\n  // Initialize graph with all registered classes\n  for (const [_key, entry] of classes) {\n    graph.set(entry.name || _key, []);\n  }\n\n  // Scan all fields for foreignKey relationships\n  for (const [_key, registered] of classes) {\n    const simpleName = registered.name || _key;\n    const dependencies: string[] = [];\n\n    for (const [_fieldName, field] of registered.fields) {\n      if (field.type === 'foreignKey' && field.related) {\n        const relatedClass = field.related;\n        // Skip self-references (table can reference itself after creation)\n        // Only add if the related class is registered and not self\n        if (\n          relatedClass !== simpleName &&\n          findClass(relatedClass) !== undefined\n        ) {\n          dependencies.push(relatedClass);\n        }\n      }\n    }\n\n    graph.set(simpleName, dependencies);\n  }\n\n  return graph;\n}\n\n/**\n * Build comprehensive relationship map from all field types.\n *\n * Returns a map containing all relationships (foreignKey, oneToMany, manyToMany)\n * discovered in registered classes.\n */\nexport function getRelationshipMap(): Map<string, RelationshipMetadata[]> {\n  const classes = getClasses();\n  const relationshipMap = new Map<string, RelationshipMetadata[]>();\n\n  // Initialize map with all registered classes\n  for (const [_key, entry] of classes) {\n    relationshipMap.set(entry.name || _key, []);\n  }\n\n  // Scan all fields for relationship types\n  for (const [_key, registered] of classes) {\n    const simpleName = registered.name || _key;\n    const relationships: RelationshipMetadata[] = [];\n\n    for (const [fieldName, field] of registered.fields) {\n      // Check for foreignKey relationships\n      if (field.type === 'foreignKey' && field.related) {\n        relationships.push({\n          sourceClass: simpleName,\n          fieldName,\n          targetClass: field.related,\n          type: 'foreignKey',\n          options: field._meta,\n        });\n      }\n\n      // Check for crossPackageRef relationships (cross-package, no DDL FK)\n      if (field.type === 'crossPackageRef' && field.related) {\n        relationships.push({\n          sourceClass: simpleName,\n          fieldName,\n          targetClass: field.related,\n          type: 'crossPackageRef',\n          options: field._meta,\n        });\n      }\n\n      // Check for oneToMany relationships\n      if (field.type === 'oneToMany' && field.related) {\n        relationships.push({\n          sourceClass: simpleName,\n          fieldName,\n          targetClass: field.related,\n          type: 'oneToMany',\n          options: field._meta,\n        });\n      }\n\n      // Check for manyToMany relationships\n      if (field.type === 'manyToMany' && field.related) {\n        relationships.push({\n          sourceClass: simpleName,\n          fieldName,\n          targetClass: field.related,\n          type: 'manyToMany',\n          options: field._meta,\n        });\n      }\n    }\n\n    relationshipMap.set(simpleName, relationships);\n  }\n\n  return relationshipMap;\n}\n"],"names":[],"mappings":";;AAmBO,SAAS,qBAA4C;AAC1D,QAAM,UAAU,WAAA;AAChB,QAAM,4BAAY,IAAA;AAGlB,aAAW,CAAC,MAAM,KAAK,KAAK,SAAS;AACnC,UAAM,IAAI,MAAM,QAAQ,MAAM,CAAA,CAAE;AAAA,EAClC;AAGA,aAAW,CAAC,MAAM,UAAU,KAAK,SAAS;AACxC,UAAM,aAAa,WAAW,QAAQ;AACtC,UAAM,eAAyB,CAAA;AAE/B,eAAW,CAAC,YAAY,KAAK,KAAK,WAAW,QAAQ;AACnD,UAAI,MAAM,SAAS,gBAAgB,MAAM,SAAS;AAChD,cAAM,eAAe,MAAM;AAG3B,YACE,iBAAiB,cACjB,UAAU,YAAY,MAAM,QAC5B;AACA,uBAAa,KAAK,YAAY;AAAA,QAChC;AAAA,MACF;AAAA,IACF;AAEA,UAAM,IAAI,YAAY,YAAY;AAAA,EACpC;AAEA,SAAO;AACT;AAQO,SAAS,qBAA0D;AACxE,QAAM,UAAU,WAAA;AAChB,QAAM,sCAAsB,IAAA;AAG5B,aAAW,CAAC,MAAM,KAAK,KAAK,SAAS;AACnC,oBAAgB,IAAI,MAAM,QAAQ,MAAM,CAAA,CAAE;AAAA,EAC5C;AAGA,aAAW,CAAC,MAAM,UAAU,KAAK,SAAS;AACxC,UAAM,aAAa,WAAW,QAAQ;AACtC,UAAM,gBAAwC,CAAA;AAE9C,eAAW,CAAC,WAAW,KAAK,KAAK,WAAW,QAAQ;AAElD,UAAI,MAAM,SAAS,gBAAgB,MAAM,SAAS;AAChD,sBAAc,KAAK;AAAA,UACjB,aAAa;AAAA,UACb;AAAA,UACA,aAAa,MAAM;AAAA,UACnB,MAAM;AAAA,UACN,SAAS,MAAM;AAAA,QAAA,CAChB;AAAA,MACH;AAGA,UAAI,MAAM,SAAS,qBAAqB,MAAM,SAAS;AACrD,sBAAc,KAAK;AAAA,UACjB,aAAa;AAAA,UACb;AAAA,UACA,aAAa,MAAM;AAAA,UACnB,MAAM;AAAA,UACN,SAAS,MAAM;AAAA,QAAA,CAChB;AAAA,MACH;AAGA,UAAI,MAAM,SAAS,eAAe,MAAM,SAAS;AAC/C,sBAAc,KAAK;AAAA,UACjB,aAAa;AAAA,UACb;AAAA,UACA,aAAa,MAAM;AAAA,UACnB,MAAM;AAAA,UACN,SAAS,MAAM;AAAA,QAAA,CAChB;AAAA,MACH;AAGA,UAAI,MAAM,SAAS,gBAAgB,MAAM,SAAS;AAChD,sBAAc,KAAK;AAAA,UACjB,aAAa;AAAA,UACb;AAAA,UACA,aAAa,MAAM;AAAA,UACnB,MAAM;AAAA,UACN,SAAS,MAAM;AAAA,QAAA,CAChB;AAAA,MACH;AAAA,IACF;AAEA,oBAAgB,IAAI,YAAY,aAAa;AAAA,EAC/C;AAEA,SAAO;AACT;"}

package/dist/registry/schema-builder.d.ts

@@ -0,0 +1,113 @@
+import { FieldDefinition } from '../scanner/types.js';
+import { ColumnDefinition, SchemaDefinition, SQLDataType } from '../schema/types.js';
+/**
+ * Get cached schema definition for a registered class
+ *
+ * @param name - Name of the registered class
+ * @returns Schema definition or undefined if not found
+ * @example
+ * ```typescript
+ * const schema = getSchema('Product');
+ * console.log(schema.tableName); // 'products'
+ * console.log(schema.ddl);       // 'CREATE TABLE...'
+ * ```
+ */
+export declare function getSchema(name: string): SchemaDefinition | undefined;
+/**
+ * Get SQL DDL statement for a registered class
+ *
+ * @param name - Name of the registered class
+ * @returns SQL DDL statement or undefined if not found
+ * @example
+ * ```typescript
+ * const ddl = ObjectRegistry.getSchemaDDL('Product');
+ * await db.query(ddl);
+ * ```
+ */
+export declare function getSchemaDDL(name: string): string | undefined;
+/**
+ * Get table name for a registered class
+ *
+ * @param name - Name of the registered class
+ * @returns Table name or undefined if not found
+ * @example
+ * ```typescript
+ * const tableName = getTableName('Product');
+ * console.log(tableName); // 'products'
+ * ```
+ */
+export declare function getTableName(name: string): string | undefined;
+/**
+ * Get all pre-generated schemas for explicit adapter bootstrap paths.
+ *
+ * Returns schemas in SDK SchemaProvider format for all registered classes.
+ * Tooling and test helpers can pass these to `getDatabase()` when they want
+ * to bootstrap schema before runtime. Core runtime no longer does this
+ * implicitly.
+ *
+ * @returns Record of table names to schema definitions
+ * @example
+ * ```typescript
+ * const schemas = ObjectRegistry.getAllSchemas();
+ * const db = await getDatabase({ type: 'json', url: './data', schemas });
+ * ```
+ */
+export declare function getAllSchemas(): Record<string, {
+    tableName: string;
+    ddl: string;
+    indexes?: string[];
+}>;
+/**
+ * Get all registered schemas as SchemaDefinition objects
+ *
+ * Similar to getAllSchemas(), but returns SchemaDefinition format suitable
+ * for use with SchemaComparer (migrations/differ.ts).
+ *
+ * Key difference: Indexes are kept as IndexDefinition objects instead of
+ * being converted to SQL strings.
+ *
+ * @returns Map of tableName to SchemaDefinition
+ */
+export declare function getAllSchemasAsDefinitions(): Record<string, SchemaDefinition>;
+/**
+ * Generate DDL CREATE TABLE statement from columns
+ *
+ * Used internally by getAllSchemas() to regenerate DDL after merging
+ * columns from multiple STI subtypes that share the same table.
+ *
+ * @param tableName - Name of the table
+ * @param columns - Column definitions
+ * @returns DDL CREATE TABLE statement
+ */
+export declare function generateDDLFromColumns(tableName: string, columns: Record<string, ColumnDefinition>, isSTI?: boolean): string;
+/**
+ * Format default value for SQL DDL.
+ *
+ * Thin wrapper over the shared, injection-safe formatter
+ * (`schema/sql-identifiers.ts`) so the registry schema-builder uses the same
+ * rules as the DDL strategies and schema generator: an allowlist of SQL
+ * keyword/function defaults (not "contains `(`"), type-driven literal quoting,
+ * and no folding of a literal string `"null"` into the SQL NULL keyword.
+ *
+ * @param value - Default value
+ * @param type - Column SQL type
+ * @returns Formatted SQL default value
+ */
+export declare function formatDefaultValue(value: any, type: string): string;
+/**
+ * Convert a Map of field definitions to column definitions
+ *
+ * Used by getAllSchemas() to generate columns from fields when a class
+ * has no pre-generated schema (e.g., STI subclasses registered from manifest).
+ *
+ * @param fields - Map of field name to field definition
+ * @returns Record of column name to column definition
+ * @private
+ */
+export declare function fieldsToColumns(fields: Map<string, FieldDefinition>): Record<string, ColumnDefinition>;
+/**
+ * Map field type to SQL data type
+ * @private
+ */
+export declare function mapFieldTypeToSQL(fieldType: FieldDefinition['type']): SQLDataType;
+//# sourceMappingURL=schema-builder.d.ts.map

package/dist/registry/schema-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-builder.d.ts","sourceRoot":"","sources":["../../src/registry/schema-builder.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAK3D,OAAO,KAAK,EACV,gBAAgB,EAEhB,gBAAgB,EAChB,WAAW,EACZ,MAAM,oBAAoB,CAAC;AAuI5B;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAIpE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE7D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAkB7D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,IAAI,MAAM,CACrC,MAAM,EACN;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CACvD,CAwMA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,IAAI,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAgK7E;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,EACzC,KAAK,UAAQ,GACZ,MAAM,CAqDR;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAEnE;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,GACnC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CA+ElC;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,eAAe,CAAC,MAAM,CAAC,GACjC,WAAW,CAqBb"}