@apso/cli 0.7.3 → 0.8.2

package/dist/lib/generators/go.js

@@ -0,0 +1,340 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoGenerator = void 0;
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const Eta = tslib_1.__importStar(require("eta"));
+const base_1 = require("./base");
+const field_1 = require("../utils/field");
+const relationships_1 = require("../utils/relationships");
+const casing_1 = require("../utils/casing");
+const pluralize_1 = tslib_1.__importDefault(require("pluralize"));
+/**
+ * Go/Gin generator that produces GORM models, DTOs, Gin handlers,
+ * and service layer code.
+ */
+class GoGenerator extends base_1.BaseGenerator {
+    constructor(config) {
+        super(config);
+        this.templateBasePath = path.join(__dirname, "../templates/go");
+        Eta.configure({
+            views: this.templateBasePath,
+            cache: false,
+        });
+    }
+    getLanguage() {
+        return "go";
+    }
+    getFileExtension() {
+        return ".go";
+    }
+    validateConfig(config) {
+        var _a;
+        const errors = [];
+        const warnings = [];
+        // Validate that entities are provided
+        if (!config.entities || config.entities.length === 0) {
+            errors.push("No entities defined in configuration");
+        }
+        // Validate each entity
+        for (const entity of config.entities) {
+            if (!entity.name) {
+                errors.push("Entity missing required 'name' property");
+            }
+            // Validate field types
+            for (const field of (_a = entity.fields) !== null && _a !== void 0 ? _a : []) {
+                if (!field.name) {
+                    errors.push(`Entity '${entity.name}' has a field without a name`);
+                }
+                if (!field.type) {
+                    errors.push(`Entity '${entity.name}' field '${field.name}' missing type`);
+                }
+                // Check for unsupported types
+                const supportedTypes = [
+                    "text",
+                    "varchar",
+                    "string",
+                    "integer",
+                    "boolean",
+                    "float",
+                    "decimal",
+                    "numeric",
+                    "date",
+                    "timestamp",
+                    "timestamptz",
+                    "json",
+                    "jsonb",
+                    "uuid",
+                    "enum",
+                    "array",
+                ];
+                if (field.type && !supportedTypes.includes(field.type)) {
+                    warnings.push(`Entity '${entity.name}' field '${field.name}' has type '${field.type}' which may not be fully supported`);
+                }
+            }
+        }
+        // Go-specific validation
+        if (config.apiType === "graphql") {
+            warnings.push("GraphQL support for Go is limited. REST API with Swagger is recommended.");
+        }
+        return this.createValidationResult(errors, warnings);
+    }
+    /**
+     * Maps .apsorc field types to Go types
+     */
+    mapFieldToGoType(field) {
+        const typeMap = {
+            text: "string",
+            varchar: "string",
+            string: "string",
+            integer: "int",
+            boolean: "bool",
+            float: "float64",
+            decimal: "float64",
+            numeric: "float64",
+            date: "time.Time",
+            timestamp: "time.Time",
+            timestamptz: "time.Time",
+            json: "map[string]interface{}",
+            jsonb: "map[string]interface{}",
+            uuid: "string",
+            enum: "string",
+            array: "[]string",
+        };
+        return typeMap[field.type || "string"] || "string";
+    }
+    /**
+     * Gets the Go type for primary keys
+     */
+    getPrimaryKeyGoType(primaryKeyType) {
+        return primaryKeyType === "uuid" ? "string" : "uint";
+    }
+    /**
+     * Gets the Swagger type for primary keys
+     */
+    getPrimaryKeySwaggerType(primaryKeyType) {
+        return primaryKeyType === "uuid" ? "string" : "integer";
+    }
+    /**
+     * Transforms fields for Go templates with additional Go-specific properties
+     */
+    getGoFieldsForTemplate(fields, entityName) {
+        const baseFields = (0, field_1.getFieldForTemplate)(fields, entityName);
+        return baseFields.map((field) => ({
+            ...field,
+            goType: this.mapFieldToGoType(field),
+            pascalName: (0, casing_1.pascalCase)(field.name),
+            snakeName: (0, casing_1.snakeCase)(field.name),
+        }));
+    }
+    async generateEntity(options) {
+        const { entity, relationships, allEntities, apiType } = options;
+        const { name, fields = [], indexes, uniques } = entity;
+        const columns = this.getGoFieldsForTemplate(fields, name);
+        const createPrimaryKey = columns.filter((column) => column.primary === true).length === 0;
+        const createdAt = entity.created_at;
+        const updatedAt = entity.updated_at;
+        const primaryKeyType = entity.primaryKeyType || "serial";
+        const relationshipsForTemplate = (0, relationships_1.getRelationshipForTemplate)(name, relationships, allEntities);
+        // Add Go-specific properties to relationships
+        const goRelationships = relationshipsForTemplate.map((rel) => ({
+            ...rel,
+            primaryKeyGoType: this.getPrimaryKeyGoType(primaryKeyType),
+            camelReferenceName: (0, casing_1.camelCase)(rel.referenceName || rel.name),
+            snakeReferenceName: (0, casing_1.snakeCase)(rel.referenceName || rel.name),
+        }));
+        const entitiesToImport = (0, relationships_1.getRelationshipsForImport)(name, relationshipsForTemplate);
+        const data = {
+            name,
+            indexes: indexes || [],
+            uniques: uniques || [],
+            createPrimaryKey,
+            primaryKeyType,
+            snakeCasedName: (0, casing_1.snakeCase)(name),
+            createdAt,
+            updatedAt,
+            pluralizedName: (0, casing_1.camelCase)((0, pluralize_1.default)(name)),
+            pluralName: (0, casing_1.pascalCase)((0, pluralize_1.default)(name)),
+            columns,
+            associations: [...new Set(goRelationships)],
+            entitiesToImport,
+            importEnums: (0, field_1.typeExistsInEntity)(entity, "enum") !== -1,
+            apiType,
+        };
+        const content = await this.renderTemplate("./models/model", data);
+        return [
+            {
+                path: `models/${(0, casing_1.snakeCase)(name)}.go`,
+                content,
+            },
+        ];
+    }
+    async generateController(options) {
+        const { entity, relationships } = options;
+        const { name: entityName } = entity;
+        const relationshipsForTemplate = (0, relationships_1.getRelationshipForTemplate)(entityName, relationships);
+        const pluralEntityName = (0, pluralize_1.default)(entityName);
+        const primaryKeyType = entity.primaryKeyType || "serial";
+        const data = {
+            entityName,
+            pluralName: (0, casing_1.pascalCase)(pluralEntityName),
+            kebabPluralName: (0, casing_1.kebabCase)(pluralEntityName),
+            primaryKeyType,
+            primaryKeyGoType: this.getPrimaryKeyGoType(primaryKeyType),
+            primaryKeySwaggerType: this.getPrimaryKeySwaggerType(primaryKeyType),
+            associations: [...new Set(relationshipsForTemplate)],
+        };
+        const content = await this.renderTemplate("./handlers/handler", data);
+        return [
+            {
+                path: `handlers/${(0, casing_1.snakeCase)(entityName)}.go`,
+                content,
+            },
+        ];
+    }
+    async generateService(options) {
+        const { entity, relationships, allEntities } = options;
+        const { name: entityName, fields = [] } = entity;
+        const columns = this.getGoFieldsForTemplate(fields, entityName);
+        const relationshipsForTemplate = (0, relationships_1.getRelationshipForTemplate)(entityName, relationships, allEntities);
+        // Add Go-specific properties to relationships
+        const goRelationships = relationshipsForTemplate.map((rel) => {
+            const referencedEntity = allEntities === null || allEntities === void 0 ? void 0 : allEntities.find((e) => e.name === rel.name);
+            const referencedPrimaryKeyType = (referencedEntity === null || referencedEntity === void 0 ? void 0 : referencedEntity.primaryKeyType) || "serial";
+            return {
+                ...rel,
+                primaryKeyGoType: this.getPrimaryKeyGoType(referencedPrimaryKeyType),
+                snakeReferenceName: (0, casing_1.snakeCase)(rel.referenceName || rel.name),
+            };
+        });
+        const pluralEntityName = (0, pluralize_1.default)(entityName);
+        const primaryKeyType = entity.primaryKeyType || "serial";
+        const createdAt = entity.created_at;
+        const updatedAt = entity.updated_at;
+        const data = {
+            entityName,
+            pluralName: (0, casing_1.pascalCase)(pluralEntityName),
+            primaryKeyType,
+            createdAt,
+            updatedAt,
+            columns,
+            associations: [...new Set(goRelationships)],
+        };
+        const content = await this.renderTemplate("./services/service", data);
+        return [
+            {
+                path: `services/${(0, casing_1.snakeCase)(entityName)}.go`,
+                content,
+            },
+        ];
+    }
+    async generateDto(options) {
+        const { entity, relationships, allEntities, apiType } = options;
+        const { name: entityName, fields = [] } = entity;
+        const columns = this.getGoFieldsForTemplate(fields, entityName);
+        const relationshipsTemplate = (0, relationships_1.getRelationshipForTemplate)(entityName, relationships, allEntities);
+        // Add Go-specific properties to relationships
+        const goRelationships = relationshipsTemplate.map((rel) => {
+            const referencedEntity = allEntities === null || allEntities === void 0 ? void 0 : allEntities.find((e) => e.name === rel.name);
+            const referencedPrimaryKeyType = (referencedEntity === null || referencedEntity === void 0 ? void 0 : referencedEntity.primaryKeyType) || "serial";
+            return {
+                ...rel,
+                primaryKeyGoType: this.getPrimaryKeyGoType(referencedPrimaryKeyType),
+                camelReferenceName: (0, casing_1.camelCase)(rel.referenceName || rel.name),
+            };
+        });
+        const primaryKeyColumns = columns.filter((column) => column.primary === true);
+        const addDefaultPKProperty = primaryKeyColumns.length === 0;
+        const createdAt = entity.created_at;
+        const updatedAt = entity.updated_at;
+        const primaryKeyType = entity.primaryKeyType || "serial";
+        const data = {
+            entityName,
+            addDefaultPKProperty,
+            primaryKeyType,
+            createdAt,
+            updatedAt,
+            columns,
+            associations: goRelationships,
+            apiType: apiType !== null && apiType !== void 0 ? apiType : "rest",
+            importEnums: (0, field_1.typeExistsInEntity)(entity, "enum") !== -1,
+        };
+        const content = await this.renderTemplate("./dto/dto", data);
+        return [
+            {
+                path: `dto/${(0, casing_1.snakeCase)(entityName)}.go`,
+                content,
+            },
+        ];
+    }
+    async generateModule(_options) {
+        // Go doesn't have a module concept like NestJS
+        // Route registration is handled in the index module
+        return [];
+    }
+    async generateMigration(_options) {
+        // Goose handles migrations differently
+        // This is a placeholder for future migration template generation
+        return [];
+    }
+    async generateEnums(entities, _apiType) {
+        if (entities.length === 0) {
+            return [];
+        }
+        const allEnumsFields = entities
+            .flatMap((entity) => (entity.fields || []).map((field) => {
+            if (field.type === "enum") {
+                return {
+                    ...field,
+                    name: (0, field_1.fieldToEnumType)(field.name, entity.name),
+                    values: (field.values || []).map((value) => ({
+                        value,
+                        pascalCase: (0, casing_1.pascalCase)(value),
+                    })),
+                };
+            }
+            return null;
+        }))
+            .filter(Boolean);
+        if (allEnumsFields.length === 0) {
+            return [];
+        }
+        const content = await this.renderTemplate("./enums", {
+            enums: allEnumsFields,
+        });
+        return [
+            {
+                path: "models/enums/enums.go",
+                content,
+            },
+        ];
+    }
+    async generateIndexModule(entities, _apiType) {
+        const entitiesData = entities.map((entity) => ({
+            name: entity.name,
+            camelName: (0, casing_1.camelCase)(entity.name),
+            kebabName: (0, casing_1.kebabCase)(entity.name),
+        }));
+        const content = await this.renderTemplate("./index-module", {
+            entities: entitiesData,
+        });
+        return [
+            {
+                path: "routes/routes.go",
+                content,
+            },
+        ];
+    }
+    async generateGuards(_entities, auth) {
+        const content = await this.renderTemplate("./middleware/auth", {
+            auth,
+        });
+        return [
+            {
+                path: "middleware/auth.go",
+                content,
+            },
+        ];
+    }
+}
+exports.GoGenerator = GoGenerator;

package/dist/lib/generators/index.d.ts

@@ -0,0 +1,21 @@
+export { BaseGenerator } from "./base";
+export { TypeScriptGenerator } from "./typescript";
+export { PythonGenerator } from "./python";
+export { GoGenerator } from "./go";
+import { TargetLanguage, GeneratorConfig, LanguageGenerator } from "../types";
+/**
+ * Factory function to create the appropriate generator for the target language
+ */
+export declare function createGenerator(config: GeneratorConfig): LanguageGenerator;
+/**
+ * Check if a language is supported
+ */
+export declare function isLanguageSupported(language: string): language is TargetLanguage;
+/**
+ * Get list of all supported languages
+ */
+export declare function getSupportedLanguages(): TargetLanguage[];
+/**
+ * Get list of currently implemented languages
+ */
+export declare function getImplementedLanguages(): TargetLanguage[];

package/dist/lib/generators/index.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getImplementedLanguages = exports.getSupportedLanguages = exports.isLanguageSupported = exports.createGenerator = exports.GoGenerator = exports.PythonGenerator = exports.TypeScriptGenerator = exports.BaseGenerator = void 0;
+var base_1 = require("./base");
+Object.defineProperty(exports, "BaseGenerator", { enumerable: true, get: function () { return base_1.BaseGenerator; } });
+var typescript_1 = require("./typescript");
+Object.defineProperty(exports, "TypeScriptGenerator", { enumerable: true, get: function () { return typescript_1.TypeScriptGenerator; } });
+var python_1 = require("./python");
+Object.defineProperty(exports, "PythonGenerator", { enumerable: true, get: function () { return python_1.PythonGenerator; } });
+var go_1 = require("./go");
+Object.defineProperty(exports, "GoGenerator", { enumerable: true, get: function () { return go_1.GoGenerator; } });
+const typescript_2 = require("./typescript");
+const python_2 = require("./python");
+const go_2 = require("./go");
+/**
+ * Factory function to create the appropriate generator for the target language
+ */
+function createGenerator(config) {
+    switch (config.language) {
+        case "typescript":
+            return new typescript_2.TypeScriptGenerator(config);
+        case "python":
+            return new python_2.PythonGenerator(config);
+        case "go":
+            return new go_2.GoGenerator(config);
+        default:
+            throw new Error(`Unsupported language: ${config.language}`);
+    }
+}
+exports.createGenerator = createGenerator;
+/**
+ * Check if a language is supported
+ */
+function isLanguageSupported(language) {
+    return ["typescript", "python", "go"].includes(language);
+}
+exports.isLanguageSupported = isLanguageSupported;
+/**
+ * Get list of all supported languages
+ */
+function getSupportedLanguages() {
+    return ["typescript", "python", "go"];
+}
+exports.getSupportedLanguages = getSupportedLanguages;
+/**
+ * Get list of currently implemented languages
+ */
+function getImplementedLanguages() {
+    return ["typescript", "python", "go"];
+}
+exports.getImplementedLanguages = getImplementedLanguages;

package/dist/lib/generators/python.d.ts

@@ -0,0 +1,21 @@
+import { BaseGenerator } from "./base";
+import { TargetLanguage, GeneratedFile, ValidationResult, GeneratorConfig, EntityGenerationOptions, ControllerGenerationOptions, ServiceGenerationOptions, DtoGenerationOptions, MigrationGenerationOptions, Entity, AuthConfig } from "../types";
+/**
+ * Python/FastAPI generator that produces SQLAlchemy models, Pydantic schemas,
+ * and FastAPI routers.
+ */
+export declare class PythonGenerator extends BaseGenerator {
+    constructor(config: GeneratorConfig);
+    getLanguage(): TargetLanguage;
+    getFileExtension(): string;
+    validateConfig(config: GeneratorConfig): ValidationResult;
+    generateEntity(options: EntityGenerationOptions): Promise<GeneratedFile[]>;
+    generateController(options: ControllerGenerationOptions): Promise<GeneratedFile[]>;
+    generateService(options: ServiceGenerationOptions): Promise<GeneratedFile[]>;
+    generateDto(options: DtoGenerationOptions): Promise<GeneratedFile[]>;
+    generateModule(_options: EntityGenerationOptions): Promise<GeneratedFile[]>;
+    generateMigration(_options: MigrationGenerationOptions): Promise<GeneratedFile[]>;
+    generateEnums(entities: Entity[], _apiType: string): Promise<GeneratedFile[]>;
+    generateIndexModule(entities: Entity[], _apiType: string): Promise<GeneratedFile[]>;
+    generateGuards(_entities: Entity[], _auth?: AuthConfig): Promise<GeneratedFile[]>;
+}

package/dist/lib/generators/python.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PythonGenerator = void 0;
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const Eta = tslib_1.__importStar(require("eta"));
+const base_1 = require("./base");
+const field_1 = require("../utils/field");
+const relationships_1 = require("../utils/relationships");
+const casing_1 = require("../utils/casing");
+const pluralize_1 = tslib_1.__importDefault(require("pluralize"));
+/**
+ * Python/FastAPI generator that produces SQLAlchemy models, Pydantic schemas,
+ * and FastAPI routers.
+ */
+class PythonGenerator extends base_1.BaseGenerator {
+    constructor(config) {
+        super(config);
+        this.templateBasePath = path.join(__dirname, "../templates/python");
+        Eta.configure({
+            views: this.templateBasePath,
+            cache: false,
+            autoTrim: false,
+        });
+    }
+    getLanguage() {
+        return "python";
+    }
+    getFileExtension() {
+        return ".py";
+    }
+    validateConfig(config) {
+        var _a;
+        const errors = [];
+        const warnings = [];
+        // Validate that entities are provided
+        if (!config.entities || config.entities.length === 0) {
+            errors.push("No entities defined in configuration");
+        }
+        // Validate each entity
+        for (const entity of config.entities) {
+            if (!entity.name) {
+                errors.push("Entity missing required 'name' property");
+            }
+            // Validate field types
+            for (const field of (_a = entity.fields) !== null && _a !== void 0 ? _a : []) {
+                if (!field.name) {
+                    errors.push(`Entity '${entity.name}' has a field without a name`);
+                }
+                if (!field.type) {
+                    errors.push(`Entity '${entity.name}' field '${field.name}' missing type`);
+                }
+                // Check for unsupported types
+                const supportedTypes = [
+                    "text",
+                    "varchar",
+                    "string",
+                    "integer",
+                    "boolean",
+                    "float",
+                    "decimal",
+                    "numeric",
+                    "date",
+                    "timestamp",
+                    "timestamptz",
+                    "json",
+                    "jsonb",
+                    "uuid",
+                    "enum",
+                    "array",
+                ];
+                if (field.type && !supportedTypes.includes(field.type)) {
+                    warnings.push(`Entity '${entity.name}' field '${field.name}' has type '${field.type}' which may not be fully supported`);
+                }
+            }
+        }
+        // Python-specific validation
+        if (config.apiType === "graphql") {
+            warnings.push("GraphQL support for Python is limited. REST API is recommended.");
+        }
+        return this.createValidationResult(errors, warnings);
+    }
+    async generateEntity(options) {
+        const { entity, relationships, allEntities, apiType } = options;
+        const { name, fields = [], indexes, uniques } = entity;
+        const columns = (0, field_1.getFieldForTemplate)(fields, name);
+        const createPrimaryKey = columns.filter((column) => column.primary === true).length === 0;
+        const createdAt = entity.created_at;
+        const updatedAt = entity.updated_at;
+        const primaryKeyType = entity.primaryKeyType || "serial";
+        const relationshipsForTemplate = (0, relationships_1.getRelationshipForTemplate)(name, relationships, allEntities);
+        const entitiesToImport = (0, relationships_1.getRelationshipsForImport)(name, relationshipsForTemplate);
+        const data = {
+            name,
+            indexes: indexes || [],
+            uniques: uniques || [],
+            createPrimaryKey,
+            primaryKeyType,
+            snakeCasedName: (0, casing_1.snakeCase)(name),
+            createdAt,
+            updatedAt,
+            pluralizedName: (0, casing_1.camelCase)((0, pluralize_1.default)(name)),
+            columns,
+            associations: [...new Set(relationshipsForTemplate)],
+            entitiesToImport,
+            importEnums: (0, field_1.typeExistsInEntity)(entity, "enum") !== -1,
+            apiType,
+        };
+        const content = await this.renderTemplate("./models/model", data);
+        return [
+            {
+                path: `models/${name.toLowerCase()}.py`,
+                content,
+            },
+        ];
+    }
+    async generateController(options) {
+        const { entity, relationships } = options;
+        const { name: entityName } = entity;
+        const relationshipsForTemplate = (0, relationships_1.getRelationshipForTemplate)(entityName, relationships);
+        const pluralEntityName = (0, pluralize_1.default)(entityName);
+        const primaryKeyType = entity.primaryKeyType || "serial";
+        const data = {
+            entityName,
+            pluralEntityName,
+            primaryKeyType,
+            associations: [...new Set(relationshipsForTemplate)],
+        };
+        const content = await this.renderTemplate("./routers/router", data);
+        return [
+            {
+                path: `routers/${entityName.toLowerCase()}.py`,
+                content,
+            },
+        ];
+    }
+    async generateService(options) {
+        const { entity, relationships } = options;
+        const { name: entityName } = entity;
+        const relationshipsForTemplate = (0, relationships_1.getRelationshipForTemplate)(entityName, relationships);
+        const pluralEntityName = (0, pluralize_1.default)(entityName);
+        const primaryKeyType = entity.primaryKeyType || "serial";
+        const data = {
+            entityName,
+            pluralEntityName,
+            primaryKeyType,
+            associations: [...new Set(relationshipsForTemplate)],
+        };
+        const content = await this.renderTemplate("./services/service", data);
+        return [
+            {
+                path: `services/${entityName.toLowerCase()}.py`,
+                content,
+            },
+        ];
+    }
+    async generateDto(options) {
+        const { entity, relationships, allEntities, apiType } = options;
+        const { name: entityName, fields = [] } = entity;
+        const columns = (0, field_1.getFieldForTemplate)(fields, entityName);
+        const relationshipsTemplate = (0, relationships_1.getRelationshipForTemplate)(entityName, relationships);
+        // Add foreign key columns for ManyToOne relationships
+        relationshipsTemplate.forEach((rel) => {
+            if (rel.type === "ManyToOne") {
+                const fkName = (0, casing_1.camelCase)(rel.referenceName || rel.name) + "Id";
+                const referencedEntity = allEntities === null || allEntities === void 0 ? void 0 : allEntities.find((e) => e.name === rel.name);
+                const referencedPrimaryKeyType = (referencedEntity === null || referencedEntity === void 0 ? void 0 : referencedEntity.primaryKeyType) || "serial";
+                const fkDataType = referencedPrimaryKeyType === "uuid" ? "string" : "number";
+                const fkType = referencedPrimaryKeyType === "uuid" ? "text" : "integer";
+                if (!columns.some((col) => col.name === fkName)) {
+                    columns.push({
+                        name: fkName,
+                        dataType: fkDataType,
+                        type: fkType,
+                    });
+                }
+            }
+        });
+        const primaryKeyColumns = columns.filter((column) => column.primary === true);
+        const addDefaultPKProperty = primaryKeyColumns.length === 0;
+        const createdAt = entity.created_at;
+        const updatedAt = entity.updated_at;
+        const primaryKeyType = entity.primaryKeyType || "serial";
+        const data = {
+            entityName,
+            addDefaultPKProperty,
+            primaryKeyType,
+            createdAt,
+            updatedAt,
+            columns,
+            associations: relationshipsTemplate,
+            apiType: apiType !== null && apiType !== void 0 ? apiType : "rest",
+            importEnums: (0, field_1.typeExistsInEntity)(entity, "enum") !== -1,
+        };
+        const content = await this.renderTemplate("./schemas/schema", data);
+        return [
+            {
+                path: `schemas/${entityName.toLowerCase()}.py`,
+                content,
+            },
+        ];
+    }
+    async generateModule(_options) {
+        // Python doesn't have a module concept like NestJS
+        // The router registration is handled in the index module
+        return [];
+    }
+    async generateMigration(_options) {
+        // Alembic handles migrations differently
+        // This is a placeholder for future migration template generation
+        return [];
+    }
+    async generateEnums(entities, _apiType) {
+        if (entities.length === 0) {
+            return [];
+        }
+        const allEnumsFields = entities
+            .flatMap((entity) => (entity.fields || []).map((field) => {
+            if (field.type === "enum") {
+                return { ...field, name: (0, field_1.fieldToEnumType)(field.name, entity.name) };
+            }
+            return null;
+        }))
+            .filter(Boolean);
+        if (allEnumsFields.length === 0) {
+            return [];
+        }
+        const content = await this.renderTemplate("./enums", {
+            allEnumsFields,
+        });
+        return [
+            {
+                path: "models/enums.py",
+                content,
+            },
+        ];
+    }
+    async generateIndexModule(entities, _apiType) {
+        const content = await this.renderTemplate("./index-module", { entities });
+        return [
+            {
+                path: "__init__.py",
+                content,
+            },
+        ];
+    }
+    async generateGuards(_entities, _auth) {
+        // Python auth/guards would be implemented differently (e.g., FastAPI dependencies)
+        // This is a placeholder for future implementation
+        return [];
+    }
+}
+exports.PythonGenerator = PythonGenerator;