@apso/cli 0.7.3 → 0.8.2

package/dist/lib/templates/rest/dto-rest.eta

@@ -1,6 +1,20 @@
 <%~ includeFile('./header.eta') %>
 
-import { ApiProperty } from '@nestjs/swagger';
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import {
+    IsString,
+    IsNumber,
+    IsBoolean,
+    IsOptional,
+    IsNotEmpty,
+    IsUUID,
+    IsDate,
+    IsArray,
+    IsEnum,
+    IsObject,
+    ValidateNested,
+} from 'class-validator';
+import { Type } from 'class-transformer';
 
 <% if (it.importEnums) { %>
 import * as enums from '../../enums';
@@ -8,70 +22,170 @@ import * as enums from '../../enums';
 
 export class <%= it.entityName %>Create {
 <% if (it.addDefaultPKProperty && (it.primaryKeyType === 'uuid' || it.primaryKeyType === 'text')) { %>
+    @ApiPropertyOptional()
+    @IsOptional()
+    @IsUUID()
+    id?: string;
+
+<% } -%>
+<% it.columns.forEach((field) => { -%>
+<% if (!field.required) { -%>
+    @ApiPropertyOptional()
+    @IsOptional()
+<% } else { -%>
     @ApiProperty()
-    id: string;
-<% } %>
-<% it.columns.forEach((field) => { %>
-    @ApiProperty()
-  <%if (field.dataType.includes("Enum")) {%>
-    <%= field.name %>: enums.<%= field.dataType %>;
-  <%} else if (field.type === 'json' || field.type === 'json-plain') {%>
-    <%= field.name %>: JSON;
-  <%} else if (field.type === 'timestamp' || field.type === 'timestamptz') {%>
-    <%= field.name %>: Date;
-  <%} else if (field.type === 'geometry' || field.type === 'geography') {%>
-    <%= field.name %>: any;
-  <%} else if (field.type === 'point') {%>
-    <%= field.name %>: { x: number, y: number };
-  <%} else if (field.type === 'linestring' || field.type === 'multipoint') {%>
-    <%= field.name %>: { coordinates: Array<{ x: number, y: number }> };
-  <%} else if (field.type === 'polygon' || field.type === 'multilinestring') {%>
-    <%= field.name %>: { coordinates: Array<Array<{ x: number, y: number }>> };
-  <%} else if (field.type === 'multipolygon') {%>
-    <%= field.name %>: { coordinates: Array<Array<Array<{ x: number, y: number }>>> };
-  <%} else if (field.type === 'geometrycollection') {%>
-    <%= field.name %>: { geometries: Array<any> };
-  <%} else {%>
-    <%= field.name %>: <%= field.dataType %>;
-  <% } %>
-<% }) %>
-};
+    @IsNotEmpty()
+<% } -%>
+<% if (field.dataType.includes("Enum")) { -%>
+    @IsEnum(enums.<%= field.dataType %>)
+    <%= field.name %><%= field.required ? '' : '?' %>: enums.<%= field.dataType %>;
+
+<% } else if (field.type === 'json' || field.type === 'json-plain') { -%>
+    @IsObject()
+    <%= field.name %><%= field.required ? '' : '?' %>: Record<string, any>;
+
+<% } else if (field.type === 'timestamp' || field.type === 'timestamptz') { -%>
+    @IsDate()
+    @Type(() => Date)
+    <%= field.name %><%= field.required ? '' : '?' %>: Date;
+
+<% } else if (field.type === 'uuid') { -%>
+    @IsUUID()
+    <%= field.name %><%= field.required ? '' : '?' %>: string;
+
+<% } else if (field.type === 'geometry' || field.type === 'geography') { -%>
+    @IsObject()
+    <%= field.name %><%= field.required ? '' : '?' %>: any;
+
+<% } else if (field.type === 'point') { -%>
+    @IsObject()
+    <%= field.name %><%= field.required ? '' : '?' %>: { x: number; y: number };
+
+<% } else if (field.type === 'linestring' || field.type === 'multipoint') { -%>
+    @IsObject()
+    <%= field.name %><%= field.required ? '' : '?' %>: { coordinates: Array<{ x: number; y: number }> };
+
+<% } else if (field.type === 'polygon' || field.type === 'multilinestring') { -%>
+    @IsObject()
+    <%= field.name %><%= field.required ? '' : '?' %>: { coordinates: Array<Array<{ x: number; y: number }>> };
+
+<% } else if (field.type === 'multipolygon') { -%>
+    @IsObject()
+    <%= field.name %><%= field.required ? '' : '?' %>: { coordinates: Array<Array<Array<{ x: number; y: number }>>> };
+
+<% } else if (field.type === 'geometrycollection') { -%>
+    @IsObject()
+    <%= field.name %><%= field.required ? '' : '?' %>: { geometries: Array<any> };
+
+<% } else if (field.type === 'array') { -%>
+    @IsArray()
+    <%= field.name %><%= field.required ? '' : '?' %>: <%= field.dataType %>;
+
+<% } else if (field.type === 'boolean') { -%>
+    @IsBoolean()
+    <%= field.name %><%= field.required ? '' : '?' %>: boolean;
+
+<% } else if (field.type === 'integer' || field.type === 'float' || field.type === 'decimal' || field.type === 'numeric') { -%>
+    @IsNumber()
+    <%= field.name %><%= field.required ? '' : '?' %>: number;
+
+<% } else { -%>
+    @IsString()
+    <%= field.name %><%= field.required ? '' : '?' %>: <%= field.dataType %>;
+
+<% } -%>
+<% }) -%>
+}
+
+export class <%= it.entityName %>Update {
+<% it.columns.forEach((field) => { -%>
+    @ApiPropertyOptional()
+    @IsOptional()
+<% if (field.dataType.includes("Enum")) { -%>
+    @IsEnum(enums.<%= field.dataType %>)
+    <%= field.name %>?: enums.<%= field.dataType %>;
+
+<% } else if (field.type === 'json' || field.type === 'json-plain') { -%>
+    @IsObject()
+    <%= field.name %>?: Record<string, any>;
+
+<% } else if (field.type === 'timestamp' || field.type === 'timestamptz') { -%>
+    @IsDate()
+    @Type(() => Date)
+    <%= field.name %>?: Date;
+
+<% } else if (field.type === 'uuid') { -%>
+    @IsUUID()
+    <%= field.name %>?: string;
+
+<% } else if (field.type === 'geometry' || field.type === 'geography') { -%>
+    @IsObject()
+    <%= field.name %>?: any;
+
+<% } else if (field.type === 'point') { -%>
+    @IsObject()
+    <%= field.name %>?: { x: number; y: number };
+
+<% } else if (field.type === 'linestring' || field.type === 'multipoint') { -%>
+    @IsObject()
+    <%= field.name %>?: { coordinates: Array<{ x: number; y: number }> };
+
+<% } else if (field.type === 'polygon' || field.type === 'multilinestring') { -%>
+    @IsObject()
+    <%= field.name %>?: { coordinates: Array<Array<{ x: number; y: number }>> };
+
+<% } else if (field.type === 'multipolygon') { -%>
+    @IsObject()
+    <%= field.name %>?: { coordinates: Array<Array<Array<{ x: number; y: number }>>> };
+
+<% } else if (field.type === 'geometrycollection') { -%>
+    @IsObject()
+    <%= field.name %>?: { geometries: Array<any> };
+
+<% } else if (field.type === 'array') { -%>
+    @IsArray()
+    <%= field.name %>?: <%= field.dataType %>;
+
+<% } else if (field.type === 'boolean') { -%>
+    @IsBoolean()
+    <%= field.name %>?: boolean;
+
+<% } else if (field.type === 'integer' || field.type === 'float' || field.type === 'decimal' || field.type === 'numeric') { -%>
+    @IsNumber()
+    <%= field.name %>?: number;
+
+<% } else { -%>
+    @IsString()
+    <%= field.name %>?: <%= field.dataType %>;
+
+<% } -%>
+<% }) -%>
+}
 
 export class <%= it.entityName %> {
 <% if (it.addDefaultPKProperty) { %>
     @ApiProperty()
     id: <%= (it.primaryKeyType === 'uuid' || it.primaryKeyType === 'text') ? 'string' : 'number' %>;
-<% } %>
-<% it.columns.forEach((field) => { %>
+
+<% } -%>
+<% it.columns.forEach((field) => { -%>
+<% if (!field.required) { -%>
+    @ApiPropertyOptional()
+    <%= field.name %>?: <% if (field.dataType.includes("Enum")) { %>enums.<%= field.dataType %><% } else if (field.type === 'json' || field.type === 'json-plain') { %>Record<string, any><% } else if (field.type === 'timestamp' || field.type === 'timestamptz') { %>Date<% } else { %><%= field.dataType %><% } %>;
+
+<% } else { -%>
     @ApiProperty()
-  <%if (field.dataType.includes("Enum")) {%>
-    <%= field.name %>: enums.<%= field.dataType %>;
-  <%} else if (field.type === 'json' || field.type === 'json-plain') {%>
-    <%= field.name %>: JSON;
-  <%} else if (field.type === 'timestamp' || field.type === 'timestamptz') {%>
-    <%= field.name %>: Date;
-  <%} else if (field.type === 'geometry' || field.type === 'geography') {%>
-    <%= field.name %>: any;
-  <%} else if (field.type === 'point') {%>
-    <%= field.name %>: { x: number, y: number };
-  <%} else if (field.type === 'linestring' || field.type === 'multipoint') {%>
-    <%= field.name %>: { coordinates: Array<{ x: number, y: number }> };
-  <%} else if (field.type === 'polygon' || field.type === 'multilinestring') {%>
-    <%= field.name %>: { coordinates: Array<Array<{ x: number, y: number }>> };
-  <%} else if (field.type === 'multipolygon') {%>
-    <%= field.name %>: { coordinates: Array<Array<Array<{ x: number, y: number }>>> };
-  <%} else if (field.type === 'geometrycollection') {%>
-    <%= field.name %>: { geometries: Array<any> };
-  <%} else {%>
-    <%= field.name %>: <%= field.dataType %>;
-  <% } %>
-<% }) %>
-<% if (it.createdAt) { %>
+    <%= field.name %>: <% if (field.dataType.includes("Enum")) { %>enums.<%= field.dataType %><% } else if (field.type === 'json' || field.type === 'json-plain') { %>Record<string, any><% } else if (field.type === 'timestamp' || field.type === 'timestamptz') { %>Date<% } else { %><%= field.dataType %><% } %>;
+
+<% } -%>
+<% }) -%>
+<% if (it.createdAt) { -%>
     @ApiProperty()
-    created_at: Date;
-<% } %>
-<% if (it.updatedAt) { %>
+    createdAt: Date;
+
+<% } -%>
+<% if (it.updatedAt) { -%>
     @ApiProperty()
-    updated_at: Date;
-<% } %>
-};
+    updatedAt: Date;
+<% } -%>
+}

package/dist/lib/templates/rest/service-rest.eta

@@ -1,25 +1,65 @@
 <%~ includeFile('./header.eta') %>
 
-import { Injectable } from "@nestjs/common";
+import { Injectable, NotFoundException } from "@nestjs/common";
 import { InjectRepository } from "@nestjs/typeorm";
 import { TypeOrmCrudService } from "@nestjsx/crud-typeorm";
-import { QueryOptions } from '@nestjsx/crud';
+import { QueryOptions, CrudRequest } from '@nestjsx/crud';
 import { ParsedRequestParams } from '@nestjsx/crud-request';
+import { Repository, DeepPartial } from 'typeorm';
 
 import {<%= it.entityName %>} from './<%= it.entityName%>.entity'
 
 @Injectable()
 export class <%= it.svcName %> extends TypeOrmCrudService<<%= it.entityName %>> {
-  constructor(@InjectRepository(<%= it.entityName %>) repo) {
+  constructor(@InjectRepository(<%= it.entityName %>) repo: Repository<<%= it.entityName %>>) {
     super(repo);
   }
 
-      /**
-      * 
-      * Solves https://github.com/nestjsx/crud/issues/777
-      */
-      getSelect(query: ParsedRequestParams, options: QueryOptions) {
-        return [...new Set(super.getSelect(query, options))]
-      }
+  /**
+   * Solves https://github.com/nestjsx/crud/issues/777
+   */
+  getSelect(query: ParsedRequestParams, options: QueryOptions) {
+    return [...new Set(super.getSelect(query, options))]
+  }
+
+  /**
+   * Override updateOne to fix NestJS CRUD bug where PATCH causes INSERT instead of UPDATE.
+   * This properly fetches the existing entity, merges with the DTO, then saves.
+   */
+  async updateOne(req: CrudRequest, dto: DeepPartial<<%= it.entityName %>>): Promise<<%= it.entityName %>> {
+    const id = req.parsed.paramsFilter?.find(f => f.field === 'id')?.value;
+    if (!id) {
+      throw new NotFoundException('<%= it.entityName %> ID not provided');
+    }
+
+    const existing = await this.repo.findOne({ where: { id } as any });
+    if (!existing) {
+      throw new NotFoundException('<%= it.entityName %> not found');
+    }
+
+    // Merge existing entity with DTO and save
+    const merged = this.repo.merge(existing, dto as any);
+    return this.repo.save(merged);
+  }
+
+  /**
+   * Override replaceOne to fix NestJS CRUD bug where PUT causes INSERT instead of UPDATE.
+   * This properly fetches the existing entity, replaces it with the DTO, then saves.
+   */
+  async replaceOne(req: CrudRequest, dto: DeepPartial<<%= it.entityName %>>): Promise<<%= it.entityName %>> {
+    const id = req.parsed.paramsFilter?.find(f => f.field === 'id')?.value;
+    if (!id) {
+      throw new NotFoundException('<%= it.entityName %> ID not provided');
+    }
+
+    const existing = await this.repo.findOne({ where: { id } as any });
+    if (!existing) {
+      throw new NotFoundException('<%= it.entityName %> not found');
+    }
+
+    // Replace with DTO (keeping the ID) and save
+    const replaced = { ...dto, id: existing.id } as <%= it.entityName %>;
+    return this.repo.save(replaced);
+  }
 }
   

package/dist/lib/types/generator.d.ts

@@ -0,0 +1,241 @@
+import { Entity } from "./entity";
+import { AuthConfig } from "./auth";
+import { RelationshipMap, Relationship } from "./relationship";
+/**
+ * Supported target languages for code generation
+ */
+export type TargetLanguage = "typescript" | "python" | "go";
+/**
+ * Represents a file to be generated
+ */
+export interface GeneratedFile {
+    /**
+     * The relative path where the file should be created
+     */
+    path: string;
+    /**
+     * The content of the file
+     */
+    content: string;
+}
+/**
+ * Result of validating a configuration for a specific language
+ */
+export interface ValidationResult {
+    /**
+     * Whether the configuration is valid
+     */
+    valid: boolean;
+    /**
+     * List of validation errors, if any
+     */
+    errors: string[];
+    /**
+     * List of validation warnings (non-fatal issues)
+     */
+    warnings: string[];
+}
+/**
+ * Language-specific configuration options
+ */
+export interface PythonLanguageConfig {
+    /**
+     * Python package name (snake_case)
+     */
+    packageName?: string;
+    /**
+     * Whether to use async mode for SQLAlchemy
+     */
+    asyncMode?: boolean;
+    /**
+     * Database URL for connection
+     */
+    databaseUrl?: string;
+}
+export interface GoLanguageConfig {
+    /**
+     * Go module name (e.g., "github.com/user/project")
+     */
+    moduleName?: string;
+    /**
+     * Package name for the main module
+     */
+    packageName?: string;
+    /**
+     * Gin mode: "debug" | "release" | "test"
+     */
+    ginMode?: "debug" | "release" | "test";
+}
+export interface TypeScriptLanguageConfig {
+    /**
+     * Whether to use strict TypeScript mode
+     */
+    strictMode?: boolean;
+}
+/**
+ * Union type of all language-specific configurations
+ */
+export type LanguageConfig = PythonLanguageConfig | GoLanguageConfig | TypeScriptLanguageConfig;
+/**
+ * Extended configuration including language settings
+ */
+export interface GeneratorConfig {
+    /**
+     * Target language for code generation
+     */
+    language: TargetLanguage;
+    /**
+     * Root folder for source code
+     */
+    rootFolder: string;
+    /**
+     * API type: "rest" or "graphql"
+     */
+    apiType: string;
+    /**
+     * All entities from the configuration
+     */
+    entities: Entity[];
+    /**
+     * Relationship map for all entities
+     */
+    relationshipMap: RelationshipMap;
+    /**
+     * Authentication configuration (optional)
+     */
+    auth?: AuthConfig;
+    /**
+     * Language-specific configuration options
+     */
+    languageConfig?: LanguageConfig;
+}
+/**
+ * Options for generating an entity
+ */
+export interface EntityGenerationOptions {
+    /**
+     * The entity definition
+     */
+    entity: Entity;
+    /**
+     * Relationships for this entity
+     */
+    relationships: Relationship[];
+    /**
+     * All entities (for cross-referencing)
+     */
+    allEntities: Entity[];
+    /**
+     * API type being generated
+     */
+    apiType: string;
+}
+/**
+ * Options for generating controllers/routers
+ */
+export interface ControllerGenerationOptions extends EntityGenerationOptions {
+    /**
+     * Relationship map for join queries
+     */
+    relationshipMap: RelationshipMap;
+}
+/**
+ * Options for generating services
+ */
+export interface ServiceGenerationOptions extends EntityGenerationOptions {
+    /**
+     * Relationship map for service methods
+     */
+    relationshipMap: RelationshipMap;
+}
+/**
+ * Options for generating DTOs/schemas
+ */
+export interface DtoGenerationOptions extends EntityGenerationOptions {
+    /**
+     * Include validation decorators/rules
+     */
+    includeValidation?: boolean;
+}
+/**
+ * Options for generating migrations
+ */
+export interface MigrationGenerationOptions {
+    /**
+     * All entities to generate migrations for
+     */
+    entities: Entity[];
+    /**
+     * Relationship map for foreign keys
+     */
+    relationshipMap: RelationshipMap;
+    /**
+     * Migration name/version
+     */
+    migrationName?: string;
+}
+/**
+ * Interface that all language-specific generators must implement
+ */
+export interface LanguageGenerator {
+    /**
+     * Get the target language this generator supports
+     */
+    getLanguage(): TargetLanguage;
+    /**
+     * Get the file extension for generated files
+     */
+    getFileExtension(): string;
+    /**
+     * Validate the configuration for this language
+     */
+    validateConfig(config: GeneratorConfig): ValidationResult;
+    /**
+     * Generate entity/model files
+     */
+    generateEntity(options: EntityGenerationOptions): Promise<GeneratedFile[]>;
+    /**
+     * Generate controller/router files
+     */
+    generateController(options: ControllerGenerationOptions): Promise<GeneratedFile[]>;
+    /**
+     * Generate service files
+     */
+    generateService(options: ServiceGenerationOptions): Promise<GeneratedFile[]>;
+    /**
+     * Generate DTO/schema files
+     */
+    generateDto(options: DtoGenerationOptions): Promise<GeneratedFile[]>;
+    /**
+     * Generate module/router registration files
+     */
+    generateModule(options: EntityGenerationOptions): Promise<GeneratedFile[]>;
+    /**
+     * Generate migration files
+     */
+    generateMigration(options: MigrationGenerationOptions): Promise<GeneratedFile[]>;
+    /**
+     * Generate enum files for all entities
+     */
+    generateEnums(entities: Entity[], apiType: string): Promise<GeneratedFile[]>;
+    /**
+     * Generate the index/main module file that ties everything together
+     */
+    generateIndexModule(entities: Entity[], apiType: string): Promise<GeneratedFile[]>;
+    /**
+     * Generate guard files (auth, scope, etc.)
+     */
+    generateGuards(entities: Entity[], auth?: AuthConfig): Promise<GeneratedFile[]>;
+}
+/**
+ * Factory function type for creating language generators
+ */
+export type GeneratorFactory = (config: GeneratorConfig) => LanguageGenerator;
+/**
+ * Registry of available generators by language
+ */
+export interface GeneratorRegistry {
+    typescript: GeneratorFactory;
+    python?: GeneratorFactory;
+    go?: GeneratorFactory;
+}

package/dist/lib/types/generator.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -4,3 +4,4 @@ export { Index } from "./indices";
 export { JSONValue } from "./json";
 export { RelationshipType, Association, ApsorcRelationship, Relationship, RelationshipForTemplate, RelationshipMap, } from "./relationship";
 export { AuthProviderType, BaseAuthConfig, DbSessionAuthConfig, JwtConfig, JwtClaimsMapping, JwtAuthConfig, ApiKeyAuthConfig, AuthConfig, AuthContext, DB_SESSION_AUTH_DEFAULTS, JWT_AUTH_DEFAULTS, API_KEY_AUTH_DEFAULTS, isDbSessionAuth, isJwtAuth, isApiKeyAuth, } from "./auth";
+export { TargetLanguage, GeneratedFile, ValidationResult, PythonLanguageConfig, GoLanguageConfig, TypeScriptLanguageConfig, LanguageConfig, GeneratorConfig, EntityGenerationOptions, ControllerGenerationOptions, ServiceGenerationOptions, DtoGenerationOptions, MigrationGenerationOptions, LanguageGenerator, GeneratorFactory, GeneratorRegistry, } from "./generator";

package/dist/lib/utils/casing.d.ts

@@ -1,3 +1,4 @@
 export declare function camelCase(str: string): string;
 export declare const snakeCase: (str: string) => string;
 export declare function pascalCase(str: string): string;
+export declare function kebabCase(str: string): string;

package/dist/lib/utils/casing.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pascalCase = exports.snakeCase = exports.camelCase = void 0;
+exports.kebabCase = exports.pascalCase = exports.snakeCase = exports.camelCase = void 0;
 function camelCase(str) {
     return (str
         // Insert a space before all caps that are followed by lower case (for PascalCase)
@@ -24,3 +24,13 @@ function pascalCase(str) {
     return c.charAt(0).toUpperCase() + c.slice(1);
 }
 exports.pascalCase = pascalCase;
+function kebabCase(str) {
+    return str
+        // Insert a hyphen before all caps that are followed by lower case (for PascalCase)
+        .replace(/([\da-z])([A-Z])/g, "$1-$2")
+        // Replace all separators with hyphens
+        .replace(/[ _]+/g, "-")
+        // Lowercase the entire string
+        .toLowerCase();
+}
+exports.kebabCase = kebabCase;

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.7.3",
+  "version": "0.8.2",
   "commands": {
     "server:new": {
       "id": "server:new",
@@ -10,7 +10,9 @@
       "pluginType": "core",
       "aliases": [],
       "examples": [
-        "$ apso server new --name TestProject"
+        "$ apso server new --name TestProject",
+        "$ apso server new --name TestProject --language python",
+        "$ apso server new --name TestProject --language go"
       ],
       "flags": {
         "name": {
@@ -26,6 +28,18 @@
           "char": "t",
           "description": "api type (rest or graphql)",
           "multiple": false
+        },
+        "language": {
+          "name": "language",
+          "type": "option",
+          "char": "l",
+          "description": "target language (typescript, python, go)",
+          "multiple": false,
+          "options": [
+            "typescript",
+            "python",
+            "go"
+          ]
         }
       },
       "args": {
@@ -43,7 +57,11 @@
       "pluginType": "core",
       "aliases": [],
       "examples": [
-        "$ apso server scaffold"
+        "$ apso server scaffold",
+        "$ apso server scaffold --skip-format",
+        "$ apso server scaffold --language typescript",
+        "$ apso server scaffold --language python",
+        "$ apso server scaffold --language go"
       ],
       "flags": {
         "help": {
@@ -52,6 +70,24 @@
           "char": "h",
           "description": "Show CLI help.",
           "allowNo": false
+        },
+        "skip-format": {
+          "name": "skip-format",
+          "type": "boolean",
+          "description": "Skip the formatting step (useful when prettier is not available)",
+          "allowNo": false
+        },
+        "language": {
+          "name": "language",
+          "type": "option",
+          "char": "l",
+          "description": "Target language for code generation (typescript, python, go). If not specified, uses .apsorc config or prompts.",
+          "multiple": false,
+          "options": [
+            "typescript",
+            "python",
+            "go"
+          ]
         }
       },
       "args": {}