@apso/cli 0.7.4 → 0.8.2

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

@@ -0,0 +1,230 @@
+/**
+ * Platform CLI Configuration Types
+ *
+ * These types define the structure of configuration and credentials
+ * stored in ~/.apso/ for platform connectivity.
+ */
+/**
+ * OAuth tokens received from the platform
+ */
+export interface PlatformTokens {
+    /**
+     * JWT access token for API calls
+     */
+    accessToken: string;
+    /**
+     * Refresh token for obtaining new access tokens
+     */
+    refreshToken: string;
+    /**
+     * When the access token expires (ISO timestamp)
+     */
+    expiresAt: string;
+    /**
+     * Token type, typically "Bearer"
+     */
+    tokenType: string;
+}
+/**
+ * User information from the platform
+ */
+export interface PlatformUser {
+    /**
+     * Unique user ID
+     */
+    id: string;
+    /**
+     * User's email address
+     */
+    email: string;
+    /**
+     * User's display name
+     */
+    name?: string;
+    /**
+     * URL to user's avatar image
+     */
+    avatarUrl?: string;
+}
+/**
+ * Workspace information from the platform
+ */
+export interface PlatformWorkspace {
+    /**
+     * Unique workspace ID
+     */
+    id: string;
+    /**
+     * URL-friendly slug
+     */
+    slug: string;
+    /**
+     * Display name
+     */
+    name: string;
+    /**
+     * Workspace type
+     */
+    type: "personal" | "company";
+}
+/**
+ * Credentials stored in ~/.apso/credentials.json
+ */
+export interface CredentialsFile {
+    /**
+     * OAuth tokens
+     */
+    tokens: PlatformTokens;
+    /**
+     * Authenticated user information
+     */
+    user: PlatformUser;
+    /**
+     * When credentials were last updated (ISO timestamp)
+     */
+    updatedAt: string;
+    /**
+     * CLI version that wrote these credentials
+     */
+    cliVersion: string;
+}
+/**
+ * Global CLI configuration stored in ~/.apso/config.json
+ */
+export interface GlobalConfigFile {
+    /**
+     * Default workspace slug to use
+     */
+    defaultWorkspace?: string;
+    /**
+     * Platform API base URL
+     */
+    apiUrl: string;
+    /**
+     * Platform web app URL (for OAuth)
+     */
+    webUrl: string;
+    /**
+     * Enable verbose logging
+     */
+    verbose: boolean;
+    /**
+     * Disable colored output
+     */
+    noColor: boolean;
+    /**
+     * Disable telemetry
+     */
+    telemetryDisabled: boolean;
+}
+/**
+ * Project link stored in .apso/link.json
+ */
+export interface ProjectLinkFile {
+    /**
+     * Linked workspace ID
+     */
+    workspaceId: string;
+    /**
+     * Linked workspace slug
+     */
+    workspaceSlug: string;
+    /**
+     * Linked service ID
+     */
+    serviceId: string;
+    /**
+     * Linked service slug
+     */
+    serviceSlug: string;
+    /**
+     * GitHub repository (if connected)
+     */
+    githubRepo?: string;
+    /**
+     * GitHub branch
+     */
+    githubBranch?: string;
+    /**
+     * When the link was created (ISO timestamp)
+     */
+    linkedAt: string;
+    /**
+     * Last successful sync (ISO timestamp)
+     */
+    lastSyncedAt?: string;
+    /**
+     * Hash of local schema at last sync
+     */
+    localSchemaHash?: string;
+    /**
+     * Hash of remote schema at last sync
+     */
+    remoteSchemaHash?: string;
+}
+/**
+ * Sync queue item for offline operations
+ */
+export interface SyncQueueItem {
+    /**
+     * Unique operation ID
+     */
+    id: string;
+    /**
+     * Type of operation
+     */
+    type: "push" | "pull" | "sync";
+    /**
+     * When the operation was queued (ISO timestamp)
+     */
+    queuedAt: string;
+    /**
+     * Operation payload
+     */
+    payload: {
+        /**
+         * Schema snapshot at queue time
+         */
+        schemaSnapshot?: unknown;
+        /**
+         * Additional metadata
+         */
+        metadata?: Record<string, unknown>;
+    };
+    /**
+     * Number of retry attempts
+     */
+    retryCount: number;
+    /**
+     * Last error message if retried
+     */
+    lastError?: string;
+}
+/**
+ * Sync queue file stored in .apso/sync-queue.json
+ */
+export interface SyncQueueFile {
+    /**
+     * Schema version for migrations
+     */
+    version: number;
+    /**
+     * Queued operations
+     */
+    operations: SyncQueueItem[];
+}
+/**
+ * Default values for global configuration
+ */
+export declare const DEFAULT_GLOBAL_CONFIG: GlobalConfigFile;
+/**
+ * Environment variables that can override configuration
+ */
+export declare const CONFIG_ENV_VARS: {
+    readonly APSO_API_URL: "apiUrl";
+    readonly APSO_WEB_URL: "webUrl";
+    readonly APSO_DEBUG: "verbose";
+    readonly APSO_NO_COLOR: "noColor";
+    readonly APSO_PROFILE: "profile";
+    readonly APSO_CONFIG_DIR: "configDir";
+};

package/dist/lib/config/types.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * Platform CLI Configuration Types
+ *
+ * These types define the structure of configuration and credentials
+ * stored in ~/.apso/ for platform connectivity.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG_ENV_VARS = exports.DEFAULT_GLOBAL_CONFIG = void 0;
+/**
+ * Default values for global configuration
+ */
+exports.DEFAULT_GLOBAL_CONFIG = {
+    apiUrl: "https://api.apso.ai",
+    webUrl: "https://app.apso.ai",
+    verbose: false,
+    noColor: false,
+    telemetryDisabled: false,
+};
+/**
+ * Environment variables that can override configuration
+ */
+exports.CONFIG_ENV_VARS = {
+    APSO_API_URL: "apiUrl",
+    APSO_WEB_URL: "webUrl",
+    APSO_DEBUG: "verbose",
+    APSO_NO_COLOR: "noColor",
+    APSO_PROFILE: "profile",
+    APSO_CONFIG_DIR: "configDir",
+};

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

@@ -0,0 +1,93 @@
+import * as Eta from "eta";
+import { TargetLanguage, GeneratedFile, ValidationResult, GeneratorConfig, EntityGenerationOptions, ControllerGenerationOptions, ServiceGenerationOptions, DtoGenerationOptions, MigrationGenerationOptions, LanguageGenerator, Entity, AuthConfig } from "../types";
+/**
+ * Abstract base class for language-specific generators.
+ * Provides common functionality and enforces the LanguageGenerator interface.
+ */
+export declare abstract class BaseGenerator implements LanguageGenerator {
+    protected config: GeneratorConfig;
+    protected templateEngine: typeof Eta;
+    protected templateBasePath: string;
+    constructor(config: GeneratorConfig);
+    /**
+     * Get the target language this generator supports
+     */
+    abstract getLanguage(): TargetLanguage;
+    /**
+     * Get the file extension for generated files (e.g., ".ts", ".py", ".go")
+     */
+    abstract getFileExtension(): string;
+    /**
+     * Validate the configuration for this language
+     */
+    abstract validateConfig(config: GeneratorConfig): ValidationResult;
+    /**
+     * Generate entity/model files
+     */
+    abstract generateEntity(options: EntityGenerationOptions): Promise<GeneratedFile[]>;
+    /**
+     * Generate controller/router files
+     */
+    abstract generateController(options: ControllerGenerationOptions): Promise<GeneratedFile[]>;
+    /**
+     * Generate service files
+     */
+    abstract generateService(options: ServiceGenerationOptions): Promise<GeneratedFile[]>;
+    /**
+     * Generate DTO/schema files
+     */
+    abstract generateDto(options: DtoGenerationOptions): Promise<GeneratedFile[]>;
+    /**
+     * Generate module/router registration files
+     */
+    abstract generateModule(options: EntityGenerationOptions): Promise<GeneratedFile[]>;
+    /**
+     * Generate migration files
+     */
+    abstract generateMigration(options: MigrationGenerationOptions): Promise<GeneratedFile[]>;
+    /**
+     * Generate enum files for all entities
+     */
+    abstract generateEnums(entities: Entity[], apiType: string): Promise<GeneratedFile[]>;
+    /**
+     * Generate the index/main module file
+     */
+    abstract generateIndexModule(entities: Entity[], apiType: string): Promise<GeneratedFile[]>;
+    /**
+     * Generate guard files (auth, scope, etc.)
+     */
+    abstract generateGuards(entities: Entity[], auth?: AuthConfig): Promise<GeneratedFile[]>;
+    /**
+     * Render a template file with the given data
+     */
+    protected renderTemplate(templatePath: string, data: Record<string, unknown>): Promise<string>;
+    /**
+     * Write generated files to disk
+     * Note: Sequential writes are intentional to avoid race conditions
+     */
+    protected writeFiles(baseDir: string, files: GeneratedFile[]): Promise<void>;
+    /**
+     * Get the configuration for this generator
+     */
+    getConfig(): GeneratorConfig;
+    /**
+     * Get the template base path for this generator
+     */
+    getTemplateBasePath(): string;
+    /**
+     * Helper to create a validation result
+     */
+    protected createValidationResult(errors?: string[], warnings?: string[]): ValidationResult;
+    /**
+     * Helper to check if an entity has a specific field type
+     */
+    protected entityHasFieldType(entity: Entity, fieldType: string): boolean;
+    /**
+     * Helper to get all unique field types from entities
+     */
+    protected getUniqueFieldTypes(entities: Entity[]): string[];
+    /**
+     * Helper to check if any entity has enum fields
+     */
+    protected hasEnumFields(entities: Entity[]): boolean;
+}

package/dist/lib/generators/base.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseGenerator = void 0;
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const Eta = tslib_1.__importStar(require("eta"));
+const file_system_1 = require("../utils/file-system");
+/**
+ * Abstract base class for language-specific generators.
+ * Provides common functionality and enforces the LanguageGenerator interface.
+ */
+class BaseGenerator {
+    constructor(config) {
+        this.config = config;
+        this.templateEngine = Eta;
+        this.templateBasePath = path.join(__dirname, `../templates/${this.getLanguage()}`);
+        // Configure Eta for this generator's templates
+        Eta.configure({
+            views: this.templateBasePath,
+            cache: false,
+        });
+    }
+    /**
+     * Render a template file with the given data
+     */
+    async renderTemplate(templatePath, data) {
+        const content = await this.templateEngine.renderFileAsync(templatePath, (0, file_system_1.withGeneratedMeta)(data));
+        return content;
+    }
+    /**
+     * Write generated files to disk
+     * Note: Sequential writes are intentional to avoid race conditions
+     */
+    async writeFiles(baseDir, files) {
+        for (const file of files) {
+            const fullPath = path.join(baseDir, file.path);
+            // eslint-disable-next-line no-await-in-loop
+            await (0, file_system_1.createFile)(fullPath, file.content);
+        }
+    }
+    /**
+     * Get the configuration for this generator
+     */
+    getConfig() {
+        return this.config;
+    }
+    /**
+     * Get the template base path for this generator
+     */
+    getTemplateBasePath() {
+        return this.templateBasePath;
+    }
+    /**
+     * Helper to create a validation result
+     */
+    createValidationResult(errors = [], warnings = []) {
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * Helper to check if an entity has a specific field type
+     */
+    entityHasFieldType(entity, fieldType) {
+        var _a, _b;
+        return ((_b = (_a = entity.fields) === null || _a === void 0 ? void 0 : _a.some((field) => field.type === fieldType)) !== null && _b !== void 0 ? _b : false);
+    }
+    /**
+     * Helper to get all unique field types from entities
+     */
+    getUniqueFieldTypes(entities) {
+        var _a;
+        const types = new Set();
+        for (const entity of entities) {
+            for (const field of (_a = entity.fields) !== null && _a !== void 0 ? _a : []) {
+                types.add(field.type);
+            }
+        }
+        return [...types];
+    }
+    /**
+     * Helper to check if any entity has enum fields
+     */
+    hasEnumFields(entities) {
+        return entities.some((entity) => this.entityHasFieldType(entity, "enum"));
+    }
+}
+exports.BaseGenerator = BaseGenerator;

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

@@ -0,0 +1,37 @@
+import { BaseGenerator } from "./base";
+import { TargetLanguage, GeneratedFile, ValidationResult, GeneratorConfig, EntityGenerationOptions, ControllerGenerationOptions, ServiceGenerationOptions, DtoGenerationOptions, MigrationGenerationOptions, Entity, AuthConfig } from "../types";
+/**
+ * Go/Gin generator that produces GORM models, DTOs, Gin handlers,
+ * and service layer code.
+ */
+export declare class GoGenerator extends BaseGenerator {
+    constructor(config: GeneratorConfig);
+    getLanguage(): TargetLanguage;
+    getFileExtension(): string;
+    validateConfig(config: GeneratorConfig): ValidationResult;
+    /**
+     * Maps .apsorc field types to Go types
+     */
+    private mapFieldToGoType;
+    /**
+     * Gets the Go type for primary keys
+     */
+    private getPrimaryKeyGoType;
+    /**
+     * Gets the Swagger type for primary keys
+     */
+    private getPrimaryKeySwaggerType;
+    /**
+     * Transforms fields for Go templates with additional Go-specific properties
+     */
+    private getGoFieldsForTemplate;
+    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[]>;
+}