@currentjs/gen 0.3.1 → 0.5.0

package/dist/types/configTypes.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Type definitions for the Clean Architecture module configuration
+ */
+export interface FieldDefinition {
+    type: string;
+    constraints?: {
+        min?: number;
+        max?: number;
+        pattern?: string;
+        unique?: boolean;
+    };
+}
+export interface ValueObjectConfig {
+    fields: Record<string, FieldDefinition | {
+        type: string;
+        values: string[];
+    }>;
+}
+export interface AggregateFieldConfig {
+    type: string;
+    required?: boolean;
+    unique?: boolean;
+    auto?: boolean;
+    values?: string[];
+}
+export interface AggregateConfig {
+    root?: boolean;
+    fields: Record<string, AggregateFieldConfig>;
+    entities?: string[];
+}
+export interface DomainConfig {
+    aggregates: Record<string, AggregateConfig>;
+    valueObjects?: Record<string, ValueObjectConfig>;
+}
+export interface PaginationConfig {
+    type: 'cursor' | 'offset';
+    defaults?: {
+        limit?: number;
+        maxLimit?: number;
+    };
+}
+export interface FilterFieldConfig {
+    type: string;
+    enum?: string[];
+    optional?: boolean;
+    searchIn?: string[];
+}
+export interface SortingConfig {
+    allow: string[];
+    default?: {
+        field: string;
+        order: 'asc' | 'desc';
+    };
+}
+/** Additional input field definition (type only; used in add) */
+export interface UseCaseInputAddField {
+    type: string;
+    source?: string;
+}
+export interface UseCaseInputConfig {
+    from?: string;
+    pick?: string[];
+    omit?: string[];
+    add?: Record<string, UseCaseInputAddField>;
+    validate?: Record<string, unknown>;
+    identifier?: string;
+    partial?: boolean;
+    pagination?: PaginationConfig;
+    filters?: Record<string, FilterFieldConfig>;
+    sorting?: SortingConfig;
+    parentId?: string;
+}
+export interface UseCaseOutputInclude {
+    from: string;
+    pick?: string[];
+}
+export interface UseCaseOutputConfig {
+    from?: string;
+    pick?: string[];
+    include?: Record<string, UseCaseOutputInclude>;
+    add?: Record<string, {
+        type: string;
+        source?: string;
+    }>;
+    pagination?: boolean;
+}
+export interface UseCaseDefinition {
+    input?: UseCaseInputConfig;
+    output?: UseCaseOutputConfig | 'void';
+    handlers: string[];
+    withChild?: boolean;
+}
+export interface UseCasesConfig {
+    [modelName: string]: {
+        [actionName: string]: UseCaseDefinition;
+    };
+}
+/**
+ * Auth configuration for endpoints.
+ * Can be:
+ * - 'all': Public access (no authentication required)
+ * - 'authenticated': Any logged-in user
+ * - 'owner': User must own the resource (checks owner_id field)
+ * - string (e.g., 'admin', 'editor'): User must have this role
+ * - string[] (e.g., ['owner', 'admin']): User must match ANY of these (OR logic)
+ */
+export type AuthConfig = 'all' | 'authenticated' | 'owner' | string | string[];
+export interface ApiEndpointConfig {
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    path: string;
+    useCase: string;
+    auth?: AuthConfig;
+}
+export interface ApiResourceConfig {
+    prefix: string;
+    endpoints: ApiEndpointConfig[];
+}
+export type ApiConfig = Record<string, ApiResourceConfig>;
+export interface WebPageConfig {
+    path: string;
+    method?: 'GET' | 'POST';
+    useCase?: string;
+    view?: string;
+    auth?: AuthConfig;
+    onSuccess?: {
+        redirect?: string;
+        toast?: string;
+        back?: boolean;
+        stay?: boolean;
+    };
+    onError?: {
+        stay?: boolean;
+        toast?: string | 'error';
+    };
+}
+export interface WebResourceConfig {
+    prefix: string;
+    layout?: string;
+    pages: WebPageConfig[];
+}
+export type WebConfig = Record<string, WebResourceConfig>;
+export interface ModuleConfig {
+    domain: DomainConfig;
+    useCases: UseCasesConfig;
+    api?: ApiConfig;
+    web?: WebConfig;
+}
+export declare function isValidModuleConfig(config: any): config is ModuleConfig;

package/dist/types/configTypes.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Type definitions for the Clean Architecture module configuration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidModuleConfig = isValidModuleConfig;
+// Type guard to validate module config (domain + useCases)
+function isValidModuleConfig(config) {
+    return config && typeof config === 'object' && 'domain' in config && 'useCases' in config;
+}

package/dist/utils/childEntityUtils.d.ts

@@ -0,0 +1,18 @@
+import { ModuleConfig, AggregateFieldConfig } from '../types/configTypes';
+export interface ChildEntityInfo {
+    parentEntityName: string;
+    parentIdField: string;
+    parentTableName: string;
+}
+export interface ParentChildInfo {
+    childEntityName: string;
+    parentIdField: string;
+    childFields: Record<string, AggregateFieldConfig>;
+    childWebPrefix?: string;
+}
+export declare function buildChildEntityMap(config: ModuleConfig): Map<string, ChildEntityInfo>;
+/**
+ * Returns all child entities of a given parent aggregate, with field definitions and web prefix.
+ * Used by template and controller generators when withChild is true.
+ */
+export declare function getChildrenOfParent(config: ModuleConfig, parentName: string): ParentChildInfo[];

package/dist/utils/childEntityUtils.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildChildEntityMap = buildChildEntityMap;
+exports.getChildrenOfParent = getChildrenOfParent;
+function buildChildEntityMap(config) {
+    var _a;
+    const map = new Map();
+    if (!((_a = config.domain) === null || _a === void 0 ? void 0 : _a.aggregates) || !config.useCases) {
+        return map;
+    }
+    const aggregates = config.domain.aggregates;
+    Object.entries(aggregates).forEach(([parentName, aggregateConfig]) => {
+        const entities = aggregateConfig.entities || [];
+        entities.forEach(childName => {
+            const childUseCases = config.useCases[childName];
+            if (!childUseCases) {
+                return;
+            }
+            let parentIdField;
+            Object.values(childUseCases).forEach(useCaseDef => {
+                const input = useCaseDef.input;
+                if (input && typeof input.parentId === 'string' && !parentIdField) {
+                    parentIdField = input.parentId;
+                }
+            });
+            if (!parentIdField) {
+                return;
+            }
+            map.set(childName, {
+                parentEntityName: parentName,
+                parentIdField,
+                parentTableName: parentName.toLowerCase(),
+            });
+        });
+    });
+    return map;
+}
+/**
+ * Returns all child entities of a given parent aggregate, with field definitions and web prefix.
+ * Used by template and controller generators when withChild is true.
+ */
+function getChildrenOfParent(config, parentName) {
+    var _a, _b, _c, _d;
+    const result = [];
+    if (!((_a = config.domain) === null || _a === void 0 ? void 0 : _a.aggregates) || !config.useCases) {
+        return result;
+    }
+    const parentAggregate = config.domain.aggregates[parentName];
+    if (!((_b = parentAggregate === null || parentAggregate === void 0 ? void 0 : parentAggregate.entities) === null || _b === void 0 ? void 0 : _b.length)) {
+        return result;
+    }
+    for (const childName of parentAggregate.entities) {
+        const childUseCases = config.useCases[childName];
+        if (!childUseCases)
+            continue;
+        let parentIdField;
+        for (const useCaseDef of Object.values(childUseCases)) {
+            const input = useCaseDef.input;
+            if (input === null || input === void 0 ? void 0 : input.parentId) {
+                parentIdField = input.parentId;
+                break;
+            }
+        }
+        if (!parentIdField)
+            continue;
+        const childAggregate = config.domain.aggregates[childName];
+        if (!(childAggregate === null || childAggregate === void 0 ? void 0 : childAggregate.fields))
+            continue;
+        const childWebPrefix = (_d = (_c = config.web) === null || _c === void 0 ? void 0 : _c[childName]) === null || _d === void 0 ? void 0 : _d.prefix;
+        result.push({
+            childEntityName: childName,
+            parentIdField,
+            childFields: childAggregate.fields,
+            childWebPrefix,
+        });
+    }
+    return result;
+}

package/dist/utils/commandUtils.d.ts

@@ -0,0 +1,43 @@
+import { DomainLayerGenerator } from '../generators/domainLayerGenerator';
+import { DtoGenerator } from '../generators/dtoGenerator';
+import { UseCaseGenerator } from '../generators/useCaseGenerator';
+import { ServiceGenerator } from '../generators/serviceGenerator';
+import { ControllerGenerator } from '../generators/controllerGenerator';
+import { StoreGenerator } from '../generators/storeGenerator';
+import { TemplateGenerator } from '../generators/templateGenerator';
+export interface ModuleEntry {
+    path: string;
+    database?: string;
+    styling?: string;
+    identifiers?: string;
+}
+export interface GlobalConfig {
+    database?: string;
+    styling?: string;
+    identifiers?: string;
+}
+export interface AppConfig {
+    providers?: Record<string, string>;
+    config?: GlobalConfig;
+    modules: Record<string, ModuleEntry>;
+}
+export declare function loadAppConfig(yamlPath: string): AppConfig;
+export declare function getModuleList(config: AppConfig): string[];
+export interface ModuleEntryResolved {
+    name: string;
+    path: string;
+    database: string;
+    styling: string;
+    identifiers: string;
+}
+export declare function getModuleEntries(config: AppConfig): ModuleEntryResolved[];
+export declare function shouldIncludeModule(moduleYamlRel: string, moduleName?: string): boolean;
+export declare function createGenerators(): {
+    domainGen: DomainLayerGenerator;
+    dtoGen: DtoGenerator;
+    useCaseGen: UseCaseGenerator;
+    serviceGen: ServiceGenerator;
+    controllerGen: ControllerGenerator;
+    templateGen: TemplateGenerator;
+    storeGen: StoreGenerator;
+};

package/dist/utils/commandUtils.js

@@ -0,0 +1,124 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAppConfig = loadAppConfig;
+exports.getModuleList = getModuleList;
+exports.getModuleEntries = getModuleEntries;
+exports.shouldIncludeModule = shouldIncludeModule;
+exports.createGenerators = createGenerators;
+/**
+ * Shared command infrastructure: app config loading, module filtering, generator creation.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml_1 = require("yaml");
+const domainLayerGenerator_1 = require("../generators/domainLayerGenerator");
+const dtoGenerator_1 = require("../generators/dtoGenerator");
+const useCaseGenerator_1 = require("../generators/useCaseGenerator");
+const serviceGenerator_1 = require("../generators/serviceGenerator");
+const controllerGenerator_1 = require("../generators/controllerGenerator");
+const storeGenerator_1 = require("../generators/storeGenerator");
+const templateGenerator_1 = require("../generators/templateGenerator");
+const DEFAULT_DATABASE = 'mysql';
+const DEFAULT_STYLING = 'bootstrap';
+const DEFAULT_IDENTIFIERS = 'id';
+function loadAppConfig(yamlPath) {
+    const raw = fs.readFileSync(yamlPath, 'utf8');
+    const parsed = (0, yaml_1.parse)(raw);
+    if (!parsed || typeof parsed !== 'object') {
+        return { modules: {} };
+    }
+    const modules = parsed.modules && typeof parsed.modules === 'object' && !Array.isArray(parsed.modules)
+        ? parsed.modules
+        : {};
+    return {
+        providers: parsed.providers,
+        config: parsed.config,
+        modules
+    };
+}
+function getModuleList(config) {
+    if (!config.modules || typeof config.modules !== 'object')
+        return [];
+    return Object.values(config.modules).map((e) => e.path);
+}
+function getModuleEntries(config) {
+    var _a, _b, _c;
+    if (!config.modules || typeof config.modules !== 'object')
+        return [];
+    const global = config.config || {};
+    const database = (_a = global.database) !== null && _a !== void 0 ? _a : DEFAULT_DATABASE;
+    const styling = (_b = global.styling) !== null && _b !== void 0 ? _b : DEFAULT_STYLING;
+    const identifiers = (_c = global.identifiers) !== null && _c !== void 0 ? _c : DEFAULT_IDENTIFIERS;
+    const globalConfig = { database, styling, identifiers };
+    return Object.entries(config.modules).map(([name, entry]) => {
+        var _a, _b, _c;
+        return ({
+            name,
+            path: entry.path,
+            database: (_a = entry.database) !== null && _a !== void 0 ? _a : globalConfig.database,
+            styling: (_b = entry.styling) !== null && _b !== void 0 ? _b : globalConfig.styling,
+            identifiers: (_c = entry.identifiers) !== null && _c !== void 0 ? _c : globalConfig.identifiers
+        });
+    });
+}
+function shouldIncludeModule(moduleYamlRel, moduleName) {
+    if (!moduleName || moduleName === '*')
+        return true;
+    const moduleNameLc = moduleName.toLowerCase();
+    const relNormalized = moduleYamlRel.replace(/\\/g, '/').toLowerCase();
+    if (relNormalized.endsWith(`/${moduleNameLc}.yaml`))
+        return true;
+    const moduleYamlPath = path.isAbsolute(moduleYamlRel)
+        ? moduleYamlRel
+        : path.resolve(process.cwd(), moduleYamlRel);
+    const dirName = path.basename(path.dirname(moduleYamlPath)).toLowerCase();
+    if (dirName === moduleNameLc)
+        return true;
+    if (relNormalized.includes(`/${moduleNameLc}/`) || relNormalized.endsWith(`/${moduleNameLc}`))
+        return true;
+    return false;
+}
+function createGenerators() {
+    return {
+        domainGen: new domainLayerGenerator_1.DomainLayerGenerator(),
+        dtoGen: new dtoGenerator_1.DtoGenerator(),
+        useCaseGen: new useCaseGenerator_1.UseCaseGenerator(),
+        serviceGen: new serviceGenerator_1.ServiceGenerator(),
+        controllerGen: new controllerGenerator_1.ControllerGenerator(),
+        templateGen: new templateGenerator_1.TemplateGenerator(),
+        storeGen: new storeGenerator_1.StoreGenerator()
+    };
+}

package/dist/utils/commitUtils.d.ts

@@ -8,6 +8,9 @@ export type DiffHunk = {
     ctxBeforeOld?: string[];
     ctxAfterOld?: string[];
 };
+export interface CommitMeta {
+    [key: string]: unknown;
+}
 type StoredCommit = {
     createdAt?: string;
     files: Array<{
@@ -20,7 +23,7 @@ type StoredCommit = {
         baseHash?: string;
         resultHash?: string;
         hunks?: DiffHunk[];
-        meta?: Record<string, any>;
+        meta?: CommitMeta;
     }>;
 };
 export declare function loadAllCommitRecords(rootDir: string): Array<{

package/dist/utils/constants.d.ts

@@ -53,3 +53,13 @@ export declare const GENERATOR_SUFFIXES: {
     readonly API_CONTROLLER: "ApiController";
     readonly WEB_CONTROLLER: "WebController";
 };
+export declare const AUTH_ROLES: {
+    readonly ALL: "all";
+    readonly AUTHENTICATED: "authenticated";
+    readonly OWNER: "owner";
+};
+export declare const AUTH_ERRORS: {
+    readonly REQUIRED: "Authentication required";
+    readonly ACCESS_DENIED: "Access denied: you do not own this resource";
+    readonly INSUFFICIENT_PERMISSIONS: "Insufficient permissions";
+};

package/dist/utils/constants.js

@@ -1,7 +1,7 @@
 "use strict";
 // Common constants used across the generator
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GENERATOR_SUFFIXES = exports.SERVER = exports.MODULE_STRUCTURE = exports.DEFAULTS = exports.PATH_PATTERNS = exports.GENERATOR_MARKERS = exports.COMMON_FILES = exports.FILE_EXTENSIONS = void 0;
+exports.AUTH_ERRORS = exports.AUTH_ROLES = exports.GENERATOR_SUFFIXES = exports.SERVER = exports.MODULE_STRUCTURE = exports.DEFAULTS = exports.PATH_PATTERNS = exports.GENERATOR_MARKERS = exports.COMMON_FILES = exports.FILE_EXTENSIONS = void 0;
 // File extensions
 exports.FILE_EXTENSIONS = {
     YAML: '.yaml',
@@ -65,3 +65,15 @@ exports.GENERATOR_SUFFIXES = {
     API_CONTROLLER: 'ApiController',
     WEB_CONTROLLER: 'WebController'
 };
+// Auth roles (magic strings used in controller auth generation)
+exports.AUTH_ROLES = {
+    ALL: 'all',
+    AUTHENTICATED: 'authenticated',
+    OWNER: 'owner',
+};
+// Auth error messages (used in controller auth check generation)
+exports.AUTH_ERRORS = {
+    REQUIRED: 'Authentication required',
+    ACCESS_DENIED: 'Access denied: you do not own this resource',
+    INSUFFICIENT_PERMISSIONS: 'Insufficient permissions',
+};

package/dist/utils/diResolver.d.ts

@@ -0,0 +1,32 @@
+export interface ConstructorParam {
+    name: string;
+    type: string;
+}
+export interface ClassInfo {
+    className: string;
+    filePath: string;
+    isController: boolean;
+    isInjectable: boolean;
+    constructorParams: ConstructorParam[];
+}
+export interface InstantiationStep {
+    className: string;
+    varName: string;
+    importPath: string;
+    constructorArgs: string[];
+    isController: boolean;
+}
+export declare function parseClassFile(filePath: string): ClassInfo | null;
+export declare function scanModuleClasses(moduleDir: string): ClassInfo[];
+/**
+ * @param classes - All discovered @Injectable and @Controller classes
+ * @param providerVarByType - Default mapping from interface type to variable name (e.g., ISqlProvider -> dbMysql)
+ * @param classProviderVar - Per-class override for provider variable (className -> varName).
+ *   Used when different modules use different database providers.
+ * @param srcDir - Absolute path to src/ directory (for computing relative import paths)
+ */
+export declare function buildInstantiationOrder(classes: ClassInfo[], providerVarByType: Map<string, string>, classProviderVar: Map<string, string>, srcDir: string): InstantiationStep[];
+export declare function resolveProviderImport(importSpec: string, appTsDir: string): {
+    importPath: string;
+    className: string;
+};