@statezero/core 0.1.0

package/dist/cli/commands/syncModels.js

@@ -0,0 +1,1040 @@
+import axios from "axios";
+import * as fs from "fs/promises";
+import * as path from "path";
+import cliProgress from "cli-progress";
+import Handlebars from "handlebars";
+import _ from "lodash-es";
+import { configInstance } from "../../config.js"; // Global config singleton
+import { loadConfigFromFile } from "../configFileLoader.js";
+// --------------------
+// JSDoc Type Definitions
+// --------------------
+/**
+ * @typedef {Object} GenerateArgs
+ * // Additional arguments for generation if needed.
+ */
+/**
+ * @typedef {Object} SchemaProperty
+ * @property {string} type
+ * @property {string} [format]
+ * @property {SchemaProperty} [items]
+ * @property {Object.<string, SchemaProperty>} [properties]
+ * @property {string[]} [required]
+ * @property {string[]} [enum]
+ * @property {string} [description]
+ * @property {boolean} [nullable]
+ * @property {any} [default]
+ * @property {string} [ref]
+ */
+/**
+ * @typedef {Object} RelationshipField
+ * @property {string} field - Name of the relationship field
+ * @property {string} ModelClass - The class name of the related model
+ * @property {string} relationshipType - Type of relationship (e.g., "many-to-many", "foreign-key")
+ */
+/**
+ * @typedef {Object} RelationshipData
+ * @property {string} type
+ * @property {string} model - e.g. "django_app.deepmodellevel1"
+ * @property {string} class_name - e.g. "DeepModelLevel1"
+ * @property {string} primary_key_field
+ */
+/**
+ * @typedef {Object} SchemaDefinition
+ * @property {string} type
+ * @property {Object.<string, SchemaProperty>} properties
+ * @property {string[]} [required]
+ * @property {string} [description]
+ * @property {Object.<string, SchemaDefinition>} [definitions]
+ * @property {string} model_name
+ * @property {string} class_name
+ * @property {string} [primary_key_field]
+ * @property {Object.<string, RelationshipData>} [relationships]
+ */
+/**
+ * @typedef {Object} PropertyDefinition
+ * @property {string} name
+ * @property {string} type
+ * @property {boolean} required
+ * @property {string} defaultValue
+ * @property {boolean} [isRelationship]
+ * @property {string} [relationshipClassName]
+ * @property {boolean} [isArrayRelationship]
+ * @property {string} [relationshipPrimaryKeyField]
+ * @property {boolean} [isString]
+ * @property {boolean} [isNumber]
+ * @property {boolean} [isBoolean]
+ * @property {boolean} [isDate]
+ * @property {boolean} [isPrimaryKey]
+ */
+/**
+ * @typedef {Object} TemplateData
+ * @property {string} modulePath           - Dynamic module path for imports.
+ * @property {string} className            - Exported full model class name (from schema.class_name).
+ * @property {string} interfaceName        - Full model fields interface name (e.g. DeepModelLevel1Fields).
+ * @property {string} modelName            - Raw schema.model_name (including app label path).
+ * @property {PropertyDefinition[]} properties
+ * @property {RelationshipField[]} relationshipFields - List of relationship fields for the model
+ * @property {string} [description]
+ * @property {string[]} [definitions]
+ * @property {string[]} [jsImports]        - For JS generation: full class imports.
+ * @property {string[]} [tsImports]        - For TS generation: type imports (Fields).
+ * @property {string} configKey            - The backend config key.
+ * @property {string} primaryKeyField      - Primary key field from schema.
+ */
+/**
+ * @typedef {Object} BackendConfig
+ * @property {string} NAME
+ * @property {string} API_URL
+ * @property {string} GENERATED_TYPES_DIR
+ */
+/**
+ * @typedef {Object} SelectedModel
+ * @property {BackendConfig} backend
+ * @property {string} model
+ */
+// --------------------
+// Handlebars Templates & Helpers
+// --------------------
+// Updated JS_MODEL_TEMPLATE with getters and setters
+const JS_MODEL_TEMPLATE = `/**
+ * This file was auto-generated. Do not make direct changes to the file.
+{{#if description}}
+ * {{description}}
+{{/if}}
+ */
+
+import { Model, Manager, QuerySet, getModelClass } from '{{modulePath}}';
+import { wrapReactiveModel } from '{{modulePath}}';
+import schemaData from './{{className}}.schema.json';
+
+/**
+ * Model-specific QuerySet implementation
+ */
+export class {{className}}QuerySet extends QuerySet {
+  // QuerySet implementation with model-specific typing
+}
+
+/**
+ * Model-specific Manager implementation
+ */
+export class {{className}}Manager extends Manager {
+  constructor(ModelClass) {
+    super(ModelClass, {{className}}QuerySet);
+  }
+  
+  newQuerySet() {
+    return new {{className}}QuerySet(this.ModelClass);
+  }
+}
+
+/**
+ * Implementation of the {{className}} model
+ */
+export class {{className}} extends Model {
+  // Bind this model to its backend
+  static configKey = '{{configKey}}';
+  static modelName = '{{modelName}}';
+  static primaryKeyField = '{{primaryKeyField}}';
+  static objects = new {{className}}Manager({{className}});
+  static fields = [{{#each properties}}'{{name}}'{{#unless @last}}, {{/unless}}{{/each}}];
+  static schema = schemaData;
+  static relationshipFields = new Map([
+    {{#each relationshipFields}}
+    ['{{field}}', { 'ModelClass': () => getModelClass('{{modelName}}', '{{../configKey}}'), 'relationshipType': '{{relationshipType}}' }]{{#unless @last}},{{/unless}}
+    {{/each}}
+  ]);
+
+  constructor(data) {
+    {{className}}.validateFields(data);
+    super(data);
+    
+    // Define getters and setters for all fields
+    this._defineProperties();
+    
+    return wrapReactiveModel(this);
+  }
+  
+  /**
+   * Define property getters and setters for all model fields
+   * @private
+   */
+  _defineProperties() {
+    // For each field, define a property that gets/sets from internal storage
+    {{className}}.fields.forEach(field => {
+      Object.defineProperty(this, field, {
+        get: function() {
+          return this.getField(field);
+        },
+        set: function(value) {
+          this.setField(field, value);
+        },
+        enumerable: true, // Make sure fields are enumerable for serialization
+        configurable: true
+      });
+    });
+  }
+
+  /**
+   * Serialize the model's data.
+   * Returns a plain object containing the current values of all fields,
+   * including raw IDs for relationship fields.
+   * @returns {Object}
+   */
+  serialize() {
+    const data = {};
+    // Simply assign the current value of each field.
+    // No special handling or PK extraction for relationships here.
+    {{#each properties}}
+    data.{{name}} = this.{{name}};
+    {{/each}}
+    return data;
+  }
+}
+`;
+// Updated TS_DECLARATION_TEMPLATE with improved relationship handling
+const TS_DECLARATION_TEMPLATE = `/**
+ * This file was auto-generated. Do not make direct changes to the file.
+{{#if description}}
+ * {{description}}
+{{/if}}
+ */
+
+import { Model, Manager } from '{{modulePath}}';
+import { StringOperators, NumberOperators, BooleanOperators, DateOperators } from '{{modulePath}}';
+import { QuerySet, LiveQuerySet, LiveQuerySetOptions, MetricResult, ResultTuple, SerializerOptions, NestedPaths } from '{{modulePath}}';
+
+// Re-export the real Manager for runtime use
+import { Manager as RuntimeManager } from '{{modulePath}}';
+{{#if tsImports}}
+{{#each tsImports}}
+{{{this}}}
+{{/each}}
+{{/if}}
+
+/**
+ * Base fields interface - defines the shape of a model instance
+ * This is the single source of truth for the model's data structure
+ */
+export interface {{interfaceName}} {
+{{#each properties}}
+  {{name}}{{#unless required}}?{{/unless}}: {{{type}}};
+{{/each}}
+  // Read-only representation field
+  readonly repr: { 
+    str: string; 
+    img: string | null;
+  };
+}
+
+/**
+ * Relationship field structure
+ */
+export interface RelationshipField {
+  ModelClass: any;
+  relationshipType: string;
+}
+
+/**
+ * Relationship fields map type
+ */
+export type RelationshipFieldsMap = Map<string, RelationshipField>;
+
+/**
+ * Type for creating new instances
+ * Similar to base fields but makes ID fields optional
+ */
+export type {{className}}CreateData = {
+{{#each properties}}
+  {{name}}{{#unless isPrimaryKey}}{{#unless required}}?{{/unless}}{{else}}?{{/unless}}: {{{type}}};
+{{/each}}
+};
+
+/**
+ * Type for updating instances
+ * All fields are optional since updates can be partial
+ */
+export type {{className}}UpdateData = Partial<{{interfaceName}}>;
+
+/**
+ * Type for filtering with field lookups
+ * Supports advanced filtering with operators like __gte, __contains, etc.
+ */
+export interface {{className}}FilterData {
+{{#each properties}}
+  {{#if isRelationship}}
+    {{#if isArrayRelationship}}
+  // Many-to-many relationship field
+  {{name}}?: number;  // Exact match by ID
+  {{name}}__in?: number[];  // Match any of these IDs
+  {{name}}__isnull?: boolean;  // Check if relation exists
+    {{else}}
+  // Foreign key relationship field
+  {{name}}?: number;  // Exact match by ID
+  {{name}}__isnull?: boolean;  // Check if relation exists
+    {{/if}}
+  {{else}}
+    {{#if isString}}
+  {{name}}?: string | StringOperators;
+  {{name}}__contains?: string;
+  {{name}}__icontains?: string;
+  {{name}}__startswith?: string;
+  {{name}}__istartswith?: string;
+  {{name}}__endswith?: string;
+  {{name}}__iendswith?: string;
+  {{name}}__exact?: string;
+  {{name}}__iexact?: string;
+  {{name}}__in?: string[];
+  {{name}}__isnull?: boolean;
+    {{/if}}
+    {{#if isNumber}}
+  {{name}}?: number | NumberOperators;
+  {{name}}__gt?: number;
+  {{name}}__gte?: number;
+  {{name}}__lt?: number;
+  {{name}}__lte?: number;
+  {{name}}__exact?: number;
+  {{name}}__in?: number[];
+  {{name}}__isnull?: boolean;
+    {{/if}}
+    {{#if isBoolean}}
+  {{name}}?: boolean | BooleanOperators;
+  {{name}}__exact?: boolean;
+  {{name}}__isnull?: boolean;
+    {{/if}}
+    {{#if isDate}}
+  {{name}}?: Date | DateOperators;
+  {{name}}__gt?: Date;
+  {{name}}__gte?: Date;
+  {{name}}__lt?: Date;
+  {{name}}__lte?: Date;
+  {{name}}__exact?: Date;
+  {{name}}__in?: Date[];
+  {{name}}__isnull?: boolean;
+    {{/if}}
+  {{/if}}
+{{/each}}
+  // Support for nested filtering on related fields
+  [key: string]: any;
+  
+  // Support for Q objects
+  Q?: Array<any>;
+}
+
+/**
+ * Model-specific QuerySet with strictly typed methods
+ */
+export declare class {{className}}QuerySet extends QuerySet<any> {
+  // Chain methods
+  filter(conditions: {{className}}FilterData): {{className}}QuerySet;
+  exclude(conditions: {{className}}FilterData): {{className}}QuerySet;
+  orderBy(...fields: Array<keyof {{interfaceName}} | string>): {{className}}QuerySet;
+  search(searchQuery: string, searchFields?: Array<string>): {{className}}QuerySet;
+  
+  // Terminal methods
+  get(filters?: {{className}}FilterData, serializerOptions?: SerializerOptions): Promise<{{className}}>;
+  first(serializerOptions?: SerializerOptions): Promise<{{className}} | null>;
+  last(serializerOptions?: SerializerOptions): Promise<{{className}} | null>;
+  all(): {{className}}QuerySet;
+  count(field?: string): Promise<number>;
+  update(updates: {{className}}UpdateData): Promise<[number, Record<string, number>]>;
+  delete(): Promise<[number, Record<string, number>]>;
+  exists(): Promise<boolean>;
+  fetch(serializerOptions?: SerializerOptions): Promise<{{className}}[]>;
+}
+
+/**
+ * Model-specific Manager with strictly typed methods
+ */
+export declare class {{className}}Manager extends Manager {
+  newQuerySet(): {{className}}QuerySet;
+  filter(conditions: {{className}}FilterData): {{className}}QuerySet;
+  exclude(conditions: {{className}}FilterData): {{className}}QuerySet;
+  all(): {{className}}QuerySet;
+  get(filters?: {{className}}FilterData, serializerOptions?: SerializerOptions): Promise<{{className}}>;
+  create(data: {{className}}CreateData): Promise<{{className}}>;
+  delete(): Promise<[number, Record<string, number>]>;
+}
+
+/**
+ * Model-specific LiveQuerySet with strictly typed methods
+ */
+export declare class {{className}}LiveQuerySet extends LiveQuerySet {
+  // Data access
+  get data(): {{className}}[];
+  
+  // Chain methods
+  filter(conditions: {{className}}FilterData): {{className}}LiveQuerySet;
+  
+  // Terminal methods
+  fetch(serializerOptions?: SerializerOptions): Promise<{{className}}[]>;
+  get(filters?: {{className}}FilterData, serializerOptions?: SerializerOptions): Promise<{{className}}>;
+  create(item: {{className}}CreateData): Promise<{{className}}>;
+  update(updates: {{className}}UpdateData): Promise<{{className}}[]>;
+  delete(): Promise<void>;
+  count(field?: string): Promise<MetricResult<number>>;
+  sum(field: string): Promise<MetricResult<number>>;
+  avg(field: string): Promise<MetricResult<number>>;
+  min(field: string): Promise<MetricResult<any>>;
+  max(field: string): Promise<MetricResult<any>>;
+}
+
+/**
+ * Enhanced RuntimeManager to provide TypeScript typings
+ * This creates a concrete class that both extends RuntimeManager and matches type expectations
+ */
+export class {{className}}Manager extends RuntimeManager {
+  filter(conditions: {{className}}FilterData): ReturnType<RuntimeManager['filter']> {
+    return super.filter(conditions as any);
+  }
+  
+  get(filters?: {{className}}FilterData, serializerOptions?: SerializerOptions): Promise<{{className}}> {
+    return super.get(filters as any, serializerOptions);
+  }
+  
+  all() {
+    return super.all();
+  }
+  
+  create(data: {{className}}CreateData): Promise<{{className}}> {
+    return super.create(data);
+  }
+  
+  update(data: {{className}}UpdateData): Promise<any> {
+    return super.update(data);
+  }
+}
+
+// Class declarations
+export declare class {{className}} extends Model implements {{interfaceName}} {
+{{#each properties}}
+  {{name}}{{#unless required}}?:{{else}}:{{/unless}} {{{type}}};
+{{/each}}
+  readonly repr: { 
+    str: string; 
+    img: string | null;
+  };
+
+  static configKey: string;
+  static modelName: string;
+  static primaryKeyField: string;
+  static relationshipFields: RelationshipFieldsMap;
+  
+  // Use model-specific manager class instead of generic manager
+  static objects: {{className}}Manager;
+
+  constructor(data: Partial<{{interfaceName}}>);
+  serialize(): Partial<{{interfaceName}}>;
+}
+
+/**
+ * Runtime initialization
+ */
+{{className}}.objects = new {{className}}Manager({{className}});
+`;
+// --------------------
+// Handlebars Helpers
+// --------------------
+Handlebars.registerHelper("ifDefaultProvided", function (defaultValue, options) {
+    if (defaultValue !== "null") {
+        return options.fn(this);
+    }
+    else {
+        return options.inverse(this);
+    }
+});
+Handlebars.registerHelper("isRequired", function (required) {
+    return required ? "" : "?";
+});
+const jsTemplate = Handlebars.compile(JS_MODEL_TEMPLATE);
+const dtsTemplate = Handlebars.compile(TS_DECLARATION_TEMPLATE);
+// --------------------
+// Core Generation Functions
+// --------------------
+/**
+ * Generates the schema for a given model.
+ * @param {BackendConfig} backend
+ * @param {string} model
+ * @returns {Promise<{model: string, relativePath: string}>}
+ */
+async function generateSchemaForModel(backend, model) {
+    const schemaUrl = `${backend.API_URL}/${model}/get-schema/`;
+    const schemaResponse = await axios.get(schemaUrl);
+    /** @type {SchemaDefinition} */
+    let schema;
+    if (schemaResponse.data.components?.schemas?.[model]) {
+        schema = schemaResponse.data.components.schemas[model];
+    }
+    else if (schemaResponse.data.properties) {
+        schema = schemaResponse.data;
+    }
+    else {
+        console.error("Unexpected schema structure for model:", model);
+        throw new Error(`Invalid schema structure for model: ${model}`);
+    }
+    if (!schema.model_name) {
+        console.error(`Missing model_name attribute in schema for model: ${model}`);
+        process.exit(1);
+    }
+    const rawModelName = schema.model_name;
+    const className = schema.class_name;
+    const interfaceName = `${className}Fields`;
+    const parts = model.split(".");
+    const currentApp = parts.length > 1 ? parts[0] : "";
+    const modulePath = process.env.NODE_ENV === "test" ? "../../../src" : "@statezero/core";
+    const templateData = prepareTemplateData(modulePath, className, interfaceName, rawModelName, schema, currentApp, backend.NAME);
+    let outDir = backend.GENERATED_TYPES_DIR;
+    if (parts.length > 1) {
+        outDir = path.join(outDir, ...parts.slice(0, -1).map((p) => p.toLowerCase()));
+    }
+    await fs.mkdir(outDir, { recursive: true });
+    const schemaFilePath = path.join(outDir, `${className.toLowerCase()}.schema.json`);
+    await fs.writeFile(schemaFilePath, JSON.stringify(schema, null, 2));
+    const jsContent = jsTemplate(templateData);
+    const baseName = parts[parts.length - 1].toLowerCase();
+    const jsFilePath = path.join(outDir, `${baseName}.js`);
+    await fs.writeFile(jsFilePath, jsContent);
+    const dtsContent = dtsTemplate(templateData);
+    const dtsFilePath = path.join(outDir, `${baseName}.d.ts`);
+    await fs.writeFile(dtsFilePath, dtsContent);
+    const relativePath = "./" +
+        path
+            .relative(backend.GENERATED_TYPES_DIR, jsFilePath)
+            .replace(/\\/g, "/")
+            .replace(/\.js$/, "");
+    return { model, relativePath, className };
+}
+/**
+ * Given a related model string (e.g. "django_app.deepmodellevel1"),
+ * extract the app label and model name to construct an import path.
+ * @param {string} currentApp
+ * @param {string} relModel
+ * @returns {string}
+ */
+function getImportPath(currentApp, relModel) {
+    const parts = relModel.split(".");
+    const appLabel = parts[0];
+    const fileName = parts[parts.length - 1].toLowerCase();
+    return currentApp === appLabel
+        ? `./${fileName}`
+        : `../${appLabel}/${fileName}`;
+}
+/**
+ * Prepares template data for Handlebars.
+ * @param {string} modulePath
+ * @param {string} className
+ * @param {string} interfaceName
+ * @param {string} rawModelName
+ * @param {SchemaDefinition} schema
+ * @param {string} currentApp
+ * @param {string} configKey
+ * @returns {TemplateData}
+ */
+function prepareTemplateData(modulePath, className, interfaceName, rawModelName, schema, currentApp, configKey) {
+    /** @type {PropertyDefinition[]} */
+    const properties = [];
+    /** @type {RelationshipField[]} */
+    const relationshipFields = [];
+    const usedDefs = new Set();
+    for (const [propName, prop] of Object.entries(schema.properties)) {
+        const propType = generateTypeForProperty(prop, schema.definitions, schema.relationships, propName);
+        const isRelationship = schema.relationships && schema.relationships[propName] !== undefined;
+        const isString = prop.type === "string";
+        const isNumber = prop.type === "integer" || prop.type === "number";
+        const isBoolean = prop.type === "boolean";
+        const isDate = prop.type === "string" && prop.format === "date-time";
+        const isPrimaryKey = schema.primary_key_field === propName;
+        const propDef = {
+            name: propName,
+            type: propType,
+            required: schema.required?.includes(propName) ?? false,
+            defaultValue: getDefaultValueForType(prop),
+            isRelationship,
+            isArrayRelationship: isRelationship
+                ? propType.startsWith("Array<")
+                : false,
+            isString,
+            isNumber,
+            isBoolean,
+            isDate,
+            isPrimaryKey,
+        };
+        if (isRelationship) {
+            const relData = schema.relationships[propName];
+            propDef.relationshipClassName = relData.class_name;
+            propDef.relationshipPrimaryKeyField = relData.primary_key_field;
+            // Add to relationshipFields array with modelName for dynamic loading
+            relationshipFields.push({
+                field: propName,
+                ModelClass: relData.class_name,
+                relationshipType: prop.format, // Use the format value directly
+                modelName: relData.model, // Add the full model name for getModelClass
+            });
+        }
+        properties.push(propDef);
+        const match = propType.match(/^(\w+)Fields$/);
+        if (match && schema.definitions && schema.definitions[match[1]]) {
+            usedDefs.add(match[1]);
+        }
+        const arrMatch = propType.match(/^Array<(\w+)Fields>$/);
+        if (arrMatch && schema.definitions && schema.definitions[arrMatch[1]]) {
+            usedDefs.add(arrMatch[1]);
+        }
+    }
+    const definitionsTs = [];
+    if (schema.definitions) {
+        for (const [defKey, defSchema] of Object.entries(schema.definitions)) {
+            if (!usedDefs.has(defKey))
+                continue;
+            let tsInterface = `export interface ${defKey}Fields {`;
+            const req = defSchema.required || [];
+            for (const [propName, prop] of Object.entries(defSchema.properties)) {
+                tsInterface += `\n  ${propName}${req.includes(propName) ? "" : "?"}: ${generateTypeForProperty(prop, schema.definitions)};`;
+            }
+            tsInterface += `\n}`;
+            definitionsTs.push(tsInterface);
+        }
+    }
+    // Only add TypeScript definition imports - JS imports are handled dynamically
+    const tsImportSet = new Set();
+    if (schema.relationships) {
+        for (const [propName, rel] of Object.entries(schema.relationships)) {
+            const importPath = getImportPath(currentApp, rel.model);
+            tsImportSet.add(`import { ${rel.class_name}Fields, ${rel.class_name}QuerySet, ${rel.class_name}LiveQuerySet } from '${importPath}';`);
+        }
+    }
+    // Convert Sets to Arrays
+    const jsImports = []; // No static JS imports needed anymore
+    const tsImports = Array.from(tsImportSet);
+    let primaryKeyField = "id";
+    if (schema.primary_key_field !== undefined) {
+        primaryKeyField = schema.primary_key_field;
+    }
+    return {
+        modulePath,
+        className,
+        interfaceName,
+        modelName: rawModelName,
+        properties,
+        relationshipFields,
+        description: schema.description,
+        definitions: definitionsTs.length > 0 ? definitionsTs : undefined,
+        jsImports,
+        tsImports,
+        configKey,
+        primaryKeyField,
+    };
+}
+/**
+ * Generates a TypeScript type for a property.
+ * @param {SchemaProperty} prop
+ * @param {Object.<string, SchemaDefinition>} [definitions]
+ * @param {Object.<string, RelationshipData>} [relationships]
+ * @param {string} [propName]
+ * @returns {string}
+ */
+function generateTypeForProperty(prop, definitions, relationships, propName) {
+    if (relationships && propName && relationships[propName]) {
+        const relData = relationships[propName];
+        const idType = prop.type === "integer" || prop.type === "number"
+            ? "number"
+            : prop.type === "string"
+                ? "string"
+                : "any";
+        return prop.format === "many-to-many"
+            ? `Array<${relData.class_name}Fields | ${idType}>`
+            : `${relData.class_name}Fields | ${idType}`;
+    }
+    if (prop.ref && prop.ref.startsWith("#/components/schemas/")) {
+        const defName = prop.ref.split("/").pop() || prop.ref;
+        return `${defName}Fields`;
+    }
+    if (prop.ref) {
+        return prop.format === "many-to-many"
+            ? `Array<${prop.ref}Fields>`
+            : `${prop.ref}Fields`;
+    }
+    let tsType;
+    switch (prop.type) {
+        case "string":
+            tsType = prop.enum
+                ? prop.enum.map((v) => `'${v}'`).join(" | ")
+                : "string";
+            break;
+        case "number":
+        case "integer":
+            tsType = "number";
+            break;
+        case "boolean":
+            tsType = "boolean";
+            break;
+        case "array":
+            tsType = prop.items
+                ? `Array<${generateTypeForProperty(prop.items, definitions)}>`
+                : "any[]";
+            break;
+        case "object":
+            if (prop.format === "json") {
+                tsType = "any";
+            }
+            else if (prop.properties) {
+                const nestedProps = Object.entries(prop.properties).map(([key, value]) => {
+                    const isRequired = prop.required?.includes(key) ? "" : "?";
+                    return `${key}${isRequired}: ${generateTypeForProperty(value, definitions)}`;
+                });
+                tsType = `{ ${nestedProps.join("; ")} }`;
+            }
+            else {
+                tsType = "Record<string, any>";
+            }
+            break;
+        default:
+            tsType = "any";
+            break;
+    }
+    if (prop.nullable) {
+        tsType = `${tsType} | null`;
+    }
+    return tsType;
+}
+/**
+ * Gets the default value for a property.
+ * @param {SchemaProperty} prop
+ * @returns {string}
+ */
+function getDefaultValueForType(prop) {
+    return prop.default !== undefined ? JSON.stringify(prop.default) : "null";
+}
+/**
+ * Creates a unique alias for importing a model class based on backend, model path, and class name.
+ * Example: ('default', 'django_app.level1.deepmodel', 'DeepModel') => 'Default__django_app__level1__DeepModel'
+ * Ensures uniqueness by including sanitized path components.
+ *
+ * @param {string} backendKey - The backend configuration key (e.g., 'default', 'microservice').
+ * @param {string} modelName - The full model name string (e.g., 'django_app.level1.deepmodel').
+ * @param {string} className - The base class name (e.g., 'DeepModel').
+ * @returns {string} - A unique alias (e.g., 'Default__django_app__level1__DeepModel').
+ */
+function generateImportAlias(backendKey, modelName, className) {
+    // 1. Sanitize Backend Key
+    const sanitizedBackendKey = (backendKey.charAt(0).toUpperCase() + backendKey.slice(1)).replace(/[^a-zA-Z0-9_]/g, ""); // Allow underscore
+    // 2. Sanitize Model Path Parts (all parts except the last, which relates to className)
+    const modelPathParts = modelName.split(".").slice(0, -1); // Get path parts like ['django_app', 'level1']
+    const sanitizedModelPath = modelPathParts
+        .map((part) => part.replace(/[^a-zA-Z0-9_]/g, "_")) // Replace invalid chars with underscore
+        .join("__"); // Join parts with double underscore -> "django_app__level1"
+    // 3. Combine: Backend__Path__ClassName
+    // Ensure className itself is sanitized just in case, although usually it should be a valid identifier
+    const sanitizedClassName = className.replace(/[^a-zA-Z0-9_]/g, "_");
+    if (sanitizedModelPath) {
+        // If path parts exist, include them: Default__django_app__level1__DeepModel
+        return `${sanitizedBackendKey}__${sanitizedModelPath}__${sanitizedClassName}`;
+    }
+    else {
+        // If no path parts (e.g., modelName is just 'simplemodel'), use: Default__SimpleModel
+        return `${sanitizedBackendKey}__${sanitizedClassName}`;
+    }
+}
+/**
+ * Generates a model registry file...
+ *
+ * @param {Array<{model: string, relativePath: string, backend: string, className: string}>} generatedFiles
+ * @param {Object.<string, BackendConfig>} backendConfigs
+ * @returns {Promise<void>}
+ */
+async function generateModelRegistry(generatedFiles, backendConfigs) {
+    const registryByBackend = {};
+    const allUniqueImports = new Set();
+    for (const file of generatedFiles) {
+        const backendKey = file.backend;
+        const modelName = file.model; // e.g., 'django_app.dummymodel'
+        const originalClassName = file.className; // e.g., 'DummyModel'
+        const typesDir = backendConfigs[backendKey].GENERATED_TYPES_DIR;
+        const importPath = "./" +
+            path
+                .relative("./", path.join(typesDir, file.relativePath))
+                .replace(/\\/g, "/");
+        const importAlias = generateImportAlias(backendKey, modelName, originalClassName);
+        // Example result: 'Default__django_app__DummyModel'
+        registryByBackend[backendKey] = registryByBackend[backendKey] || {
+            imports: [],
+            models: {},
+        };
+        const importStatement = `import { ${originalClassName} as ${importAlias} } from '${importPath}.js';`;
+        registryByBackend[backendKey].imports.push(importStatement);
+        allUniqueImports.add(importStatement);
+        registryByBackend[backendKey].models[modelName] = importAlias; // Store mapping: 'django_app.dummymodel': 'Default__django_app__DummyModel'
+    }
+    // --- Generate registry content ---
+    let registryContent = `/**
+ * This file was auto-generated. Do not make direct changes to the file.
+ * It provides a registry of all models organized by config key and model name.
+ * Uses import aliases incorporating model paths to ensure uniqueness.
+ */
+
+// --- Imports ---
+`;
+    // Add all unique import statements collected
+    registryContent += Array.from(allUniqueImports).sort().join("\n");
+    registryContent += "\n\n";
+    // --- Create the registry object ---
+    registryContent += `/**
+ * Model registry mapped by configKey and modelName.
+ * Values are the aliased imported classes.
+ * @type {Object.<string, Object.<string, Function>>}
+ */
+export const MODEL_REGISTRY = {
+`;
+    // Add entries for each backend
+    const backendEntries = Object.entries(registryByBackend);
+    backendEntries.forEach(([backendKey, data], backendIndex) => {
+        registryContent += `  '${backendKey}': {\n`;
+        // Add model entries: 'model.name': Alias (e.g., 'django_app.dummymodel': Default__django_app__DummyModel)
+        const modelEntries = Object.entries(data.models);
+        modelEntries.forEach(([modelName, alias], modelIndex) => {
+            registryContent += `    '${modelName}': ${alias}`; // Use the generated alias here
+            if (modelIndex < modelEntries.length - 1) {
+                registryContent += ",";
+            }
+            registryContent += "\n";
+        });
+        registryContent += `  }`;
+        if (backendIndex < backendEntries.length - 1) {
+            registryContent += ",";
+        }
+        registryContent += "\n";
+    });
+    registryContent += `};
+
+/**
+ * Get a model class by name.
+ * This remains synchronous.
+ *
+ * @param {string} modelName - The model name (e.g., 'django_app.dummymodel')
+ * @param {string} configKey - The config key (backend name, e.g., 'default')
+ * @returns {Function|null} - The model class (via its alias) or null if not found.
+ */
+export function getModelClass(modelName, configKey) {
+  if (MODEL_REGISTRY[configKey] && MODEL_REGISTRY[configKey][modelName]) {
+    // Returns the specific aliased class for that backend/model combination
+    return MODEL_REGISTRY[configKey][modelName];
+  }
+
+  console.warn(\`Model class not found for '\${modelName}' in config '\${configKey}'\`);
+  return null;
+}
+`;
+    // --- Write the file ---
+    const rootDir = process.cwd();
+    const registryFilePath = path.join(rootDir, "model-registry.js");
+    try {
+        await fs.writeFile(registryFilePath, registryContent);
+        console.log(`✨ Generated model registry with path-based aliases at ${registryFilePath}`);
+    }
+    catch (err) {
+        console.error(`❌ Failed to write model registry at ${registryFilePath}:`, err);
+    }
+}
+/**
+ * Generates app-level index files and a root index file that imports from app indexes.
+ * @param {Array<{model: string, relativePath: string, backend: string}>} generatedFiles
+ * @param {Object.<string, BackendConfig>} backendConfigs
+ * @returns {Promise<void>}
+ */
+async function generateAppLevelIndexFiles(generatedFiles, backendConfigs) {
+    // Group files by backend and app
+    const filesByBackendAndApp = generatedFiles.reduce((acc, file) => {
+        const backend = file.backend;
+        const parts = file.model.split(".");
+        const app = parts.length > 1 ? parts[0] : "root"; // Use 'root' for models without an app
+        acc[backend] = acc[backend] || {};
+        acc[backend][app] = acc[backend][app] || [];
+        acc[backend][app].push(file);
+        return acc;
+    }, {});
+    const indexTemplate = Handlebars.compile(`{{#each files}}
+export * from '{{this.relativePath}}';
+{{/each}}`);
+    // Generate app-level index files for each backend and app
+    for (const [backendName, appGroups] of Object.entries(filesByBackendAndApp)) {
+        const backend = backendConfigs[backendName];
+        const rootExports = [];
+        for (const [app, files] of Object.entries(appGroups)) {
+            if (app === "root") {
+                // Handle models without an app prefix
+                for (const file of files) {
+                    rootExports.push(`export * from '${file.relativePath}';`);
+                }
+            }
+            else {
+                // Create app-level index files with proper relative paths
+                const appDir = path.join(backend.GENERATED_TYPES_DIR, app.toLowerCase());
+                // Create relative paths for imports within the app directory
+                // These should be relative to the app directory, not the backend root
+                const appFiles = files.map((file) => {
+                    // Get the last part of the path (the actual file name without extension)
+                    const fileName = path.basename(file.relativePath);
+                    return {
+                        ...file,
+                        relativePath: "./" + fileName,
+                    };
+                });
+                const indexContent = indexTemplate({ files: appFiles });
+                await fs.writeFile(path.join(appDir, "index.js"), indexContent.trim());
+                await fs.writeFile(path.join(appDir, "index.d.ts"), indexContent.trim());
+                // Add an export for this app's index to the backend root index
+                rootExports.push(`export * from './${app.toLowerCase()}/index';`);
+            }
+        }
+        // Write the backend root index file (add FileObject export)
+        const backendIndexContent = [
+            "export * from './fileobject';", // Add this line
+            ...rootExports,
+        ].join("\n");
+        await fs.writeFile(path.join(backend.GENERATED_TYPES_DIR, "index.js"), backendIndexContent);
+        await fs.writeFile(path.join(backend.GENERATED_TYPES_DIR, "index.d.ts"), backendIndexContent);
+    }
+}
+// FileObject template
+const FILEOBJECT_TEMPLATE = `/**
+ * This file was auto-generated. Do not make direct changes to the file.
+ * Backend-specific FileObject class for {{backendName}}
+ */
+
+import { FileObject as BaseFileObject } from '{{modulePath}}';
+
+export class {{backendName}}FileObject extends BaseFileObject {
+  static configKey = '{{backendName}}';
+}
+
+export const FileObject = {{backendName}}FileObject;
+`;
+const fileObjectTemplate = Handlebars.compile(FILEOBJECT_TEMPLATE);
+/**
+ * Generates a FileObject class for a backend.
+ * @param {BackendConfig} backend
+ * @returns {Promise<void>}
+ */
+async function generateFileObjectForBackend(backend) {
+    const modulePath = process.env.NODE_ENV === "test" ? "../../../src" : "@statezero/core";
+    const templateData = {
+        backendName: backend.NAME,
+        modulePath: modulePath,
+    };
+    const fileObjectContent = fileObjectTemplate(templateData);
+    const fileObjectPath = path.join(backend.GENERATED_TYPES_DIR, "fileobject.js");
+    await fs.writeFile(fileObjectPath, fileObjectContent);
+    // Also generate TypeScript declaration
+    const dtsContent = `/**
+ * This file was auto-generated. Do not make direct changes to the file.
+ * Backend-specific FileObject class for ${backend.NAME}
+ */
+
+import { FileObject as BaseFileObject } from '${modulePath}';
+
+export declare class ${backend.NAME}FileObject extends BaseFileObject {
+  static configKey: string;
+}
+
+export declare const FileObject: typeof ${backend.NAME}FileObject;
+`;
+    const dtsPath = path.join(backend.GENERATED_TYPES_DIR, "fileobject.d.ts");
+    await fs.writeFile(dtsPath, dtsContent);
+}
+// --------------------
+// Main Runner: Fetch models and prompt selection
+// --------------------
+// Update main function to use this new approach
+async function main() {
+    // Load configuration from file (CLI-only or tests) before any other operations.
+    loadConfigFromFile();
+    // Retrieve the validated configuration from the global config singleton.
+    const configData = configInstance.getConfig();
+    const backendConfigs = configData.backendConfigs;
+    const inquirer = (await import("inquirer")).default;
+    const fetchPromises = Object.keys(backendConfigs).map(async (key) => {
+        const backend = backendConfigs[key];
+        backend.NAME = key;
+        try {
+            const response = await axios.get(`${backend.API_URL}/models/`);
+            return { backend, models: response.data };
+        }
+        catch (error) {
+            console.error(`Error fetching models from backend ${backend.NAME}:`, error.message);
+            return { backend, models: [] };
+        }
+    });
+    const backendModels = await Promise.all(fetchPromises);
+    const choices = [];
+    for (const { backend, models } of backendModels) {
+        choices.push(new inquirer.Separator(`\n=== ${backend.NAME} ===\n`));
+        for (const model of models) {
+            choices.push({
+                name: model,
+                value: { backend, model },
+                checked: true,
+            });
+        }
+    }
+    if (choices.length === 0) {
+        console.log("No models to synchronise");
+        process.exit(0);
+    }
+    const { selectedModels } = await inquirer.prompt([
+        {
+            type: "checkbox",
+            name: "selectedModels",
+            message: "Select models to synchronise:",
+            choices,
+            pageSize: 20,
+        },
+    ]);
+    if (!selectedModels || selectedModels.length === 0) {
+        console.log("No models selected. Exiting.");
+        process.exit(0);
+    }
+    const modelsByBackend = selectedModels.reduce((acc, item) => {
+        const key = item.backend.NAME;
+        acc[key] = acc[key] || { backend: item.backend, models: [] };
+        acc[key].models.push(item.model);
+        return acc;
+    }, {});
+    const allGeneratedFiles = [];
+    for (const group of Object.values(modelsByBackend)) {
+        console.log(`\nProcessing backend: ${group.backend.NAME}`);
+        const progressBar = new cliProgress.SingleBar({}, cliProgress.Presets.shades_classic);
+        progressBar.start(group.models.length, 0);
+        for (const model of group.models) {
+            try {
+                const result = await generateSchemaForModel(group.backend, model);
+                allGeneratedFiles.push({ ...result, backend: group.backend.NAME });
+            }
+            catch (error) {
+                console.error(`Error generating schema for model ${model} from backend ${group.backend.NAME}:`, error.message);
+            }
+            progressBar.increment();
+        }
+        progressBar.stop();
+        // Generate FileObject for this backend
+        try {
+            await generateFileObjectForBackend(group.backend);
+            console.log(`✨ Generated FileObject for backend: ${group.backend.NAME}`);
+        }
+        catch (error) {
+            console.error(`Error generating FileObject for backend ${group.backend.NAME}:`, error.message);
+        }
+    }
+    // Generate an index file per app
+    await generateAppLevelIndexFiles(allGeneratedFiles, backendConfigs);
+    // Generate model registry
+    await generateModelRegistry(allGeneratedFiles, backendConfigs);
+    console.log(`✨ Generated JavaScript files with TypeScript declarations for ${selectedModels.length} models across ${Object.keys(backendConfigs).length} backends.`);
+}
+/**
+ * Main exported function to generate schema.
+ * @param {GenerateArgs} args
+ * @returns {Promise<void>}
+ */
+export async function generateSchema(args) {
+    await main();
+}