@apso/cli 0.8.6 → 0.10.1

package/dist/lib/utils/schema-convert.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Schema Conversion Utilities
+ *
+ * Converts between local .apsorc format and platform ServiceSchema format.
+ */
+import { Entity } from "../types/entity";
+import { RelationshipMap } from "../types/relationship";
+import { ServiceSchema } from "../api/types";
+/**
+ * Parsed .apsorc data shape (subset of ParsedApsorc from apsorc-parser.ts)
+ */
+export interface ParsedApsorcInput {
+    rootFolder: string;
+    apiType: string;
+    entities: Entity[];
+    relationshipMap: RelationshipMap;
+}
+/**
+ * Shape returned by serviceSchemaToApsorc for writing back to .apsorc
+ */
+export interface ApsorcOutput {
+    version: number;
+    rootFolder: string;
+    apiType: string;
+    entities: ApsorcEntityOutput[];
+    relationships: ApsorcRelationshipOutput[];
+}
+export interface ApsorcEntityOutput {
+    name: string;
+    primaryKeyType?: "serial" | "uuid";
+    created_at?: boolean;
+    updated_at?: boolean;
+    fields?: ApsorcFieldOutput[];
+    scopeBy?: string | string[];
+}
+export interface ApsorcFieldOutput {
+    name: string;
+    type: string;
+    nullable?: boolean;
+    unique?: boolean;
+    default?: unknown;
+    index?: boolean;
+}
+export interface ApsorcRelationshipOutput {
+    from: string;
+    to: string;
+    type: "OneToMany" | "ManyToOne" | "ManyToMany" | "OneToOne";
+    to_name?: string;
+    nullable?: boolean;
+    bi_directional?: boolean;
+    cascadeDelete?: boolean;
+}
+/**
+ * Convert parsed .apsorc data to platform ServiceSchema format.
+ *
+ * The local .apsorc stores relationships as a flat RelationshipMap keyed by entity name.
+ * The platform ServiceSchema stores relationships embedded per-entity.
+ */
+export declare function apsorcToServiceSchema(parsed: ParsedApsorcInput): Omit<ServiceSchema, "id" | "serviceId" | "version" | "createdAt" | "updatedAt">;
+/**
+ * Convert platform ServiceSchema to .apsorc format for writing to disk.
+ *
+ * Reverses the conversion: flattens per-entity relationships back into a
+ * top-level relationships array in v2 format.
+ */
+export declare function serviceSchemaToApsorc(schema: ServiceSchema): ApsorcOutput;
+/**
+ * Compute a SHA-256 hash of a schema for sync tracking.
+ * Uses deterministic JSON serialization (recursively sorted keys).
+ */
+export declare function computeSchemaHash(schema: unknown): string;

package/dist/lib/utils/schema-convert.js

@@ -0,0 +1,169 @@
+"use strict";
+/**
+ * Schema Conversion Utilities
+ *
+ * Converts between local .apsorc format and platform ServiceSchema format.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeSchemaHash = exports.serviceSchemaToApsorc = exports.apsorcToServiceSchema = void 0;
+const tslib_1 = require("tslib");
+const crypto = tslib_1.__importStar(require("crypto"));
+/**
+ * Map from SchemaRelationship type format to ApsorcRelationship type format
+ */
+function platformTypeToApsorcType(type) {
+    const map = {
+        "one-to-one": "OneToOne",
+        "one-to-many": "OneToMany",
+        "many-to-one": "ManyToOne",
+        "many-to-many": "ManyToMany",
+    };
+    return map[type];
+}
+/**
+ * Map from ApsorcRelationship type format to SchemaRelationship type format
+ */
+function apsorcTypeToPlatformType(type) {
+    const map = {
+        OneToOne: "one-to-one",
+        OneToMany: "one-to-many",
+        ManyToOne: "many-to-one",
+        ManyToMany: "many-to-many",
+    };
+    return map[type] || "many-to-one";
+}
+/**
+ * Convert parsed .apsorc data to platform ServiceSchema format.
+ *
+ * The local .apsorc stores relationships as a flat RelationshipMap keyed by entity name.
+ * The platform ServiceSchema stores relationships embedded per-entity.
+ */
+function apsorcToServiceSchema(parsed) {
+    const entities = parsed.entities.map((entity) => {
+        // Convert fields
+        const fields = (entity.fields || []).map((field) => {
+            var _a;
+            return ({
+                name: field.name,
+                type: field.type,
+                nullable: field.nullable,
+                unique: field.unique,
+                default: (_a = field.default) !== null && _a !== void 0 ? _a : undefined,
+                primaryKey: field.primary,
+                index: field.index,
+            });
+        });
+        // Get relationships for this entity from the map
+        const entityRelationships = parsed.relationshipMap[entity.name] || [];
+        const relationships = entityRelationships.map((rel) => ({
+            name: rel.name,
+            type: apsorcTypeToPlatformType(rel.type),
+            target: rel.name,
+            inverseSide: rel.referenceName || undefined,
+            cascade: rel.cascadeDelete,
+            nullable: rel.nullable,
+        }));
+        const schemaEntity = {
+            name: entity.name,
+            fields,
+            relationships: relationships.length > 0 ? relationships : undefined,
+            scopeBy: entity.scopeBy
+                ? Array.isArray(entity.scopeBy)
+                    ? entity.scopeBy
+                    : [entity.scopeBy]
+                : undefined,
+        };
+        return schemaEntity;
+    });
+    return { entities };
+}
+exports.apsorcToServiceSchema = apsorcToServiceSchema;
+/**
+ * Convert platform ServiceSchema to .apsorc format for writing to disk.
+ *
+ * Reverses the conversion: flattens per-entity relationships back into a
+ * top-level relationships array in v2 format.
+ */
+function serviceSchemaToApsorc(schema) {
+    const entities = [];
+    const relationships = [];
+    for (const schemaEntity of schema.entities) {
+        // Convert fields back to .apsorc format
+        const fields = (schemaEntity.fields || [])
+            .filter((f) => !f.primaryKey) // Primary keys are implicit in .apsorc
+            .map((field) => {
+            const out = {
+                name: field.name,
+                type: field.type,
+            };
+            if (field.nullable)
+                out.nullable = true;
+            if (field.unique)
+                out.unique = true;
+            if (field.default !== undefined)
+                out.default = field.default;
+            if (field.index)
+                out.index = true;
+            return out;
+        });
+        const entityOut = {
+            name: schemaEntity.name,
+        };
+        if (fields.length > 0) {
+            entityOut.fields = fields;
+        }
+        if (schemaEntity.scopeBy && schemaEntity.scopeBy.length > 0) {
+            entityOut.scopeBy =
+                schemaEntity.scopeBy.length === 1
+                    ? schemaEntity.scopeBy[0]
+                    : schemaEntity.scopeBy;
+        }
+        entities.push(entityOut);
+        // Convert per-entity relationships to flat array
+        if (schemaEntity.relationships) {
+            for (const rel of schemaEntity.relationships) {
+                relationships.push({
+                    from: schemaEntity.name,
+                    to: rel.target,
+                    type: platformTypeToApsorcType(rel.type),
+                    to_name: rel.inverseSide || undefined,
+                    nullable: rel.nullable,
+                    cascadeDelete: rel.cascade,
+                });
+            }
+        }
+    }
+    return {
+        version: 2,
+        rootFolder: "src",
+        apiType: "rest",
+        entities,
+        relationships,
+    };
+}
+exports.serviceSchemaToApsorc = serviceSchemaToApsorc;
+/**
+ * Recursively sort all object keys for deterministic serialization.
+ */
+function sortKeys(value) {
+    if (Array.isArray(value)) {
+        return value.map(sortKeys);
+    }
+    if (value !== null && typeof value === "object") {
+        const sorted = {};
+        for (const key of Object.keys(value).sort()) {
+            sorted[key] = sortKeys(value[key]);
+        }
+        return sorted;
+    }
+    return value;
+}
+/**
+ * Compute a SHA-256 hash of a schema for sync tracking.
+ * Uses deterministic JSON serialization (recursively sorted keys).
+ */
+function computeSchemaHash(schema) {
+    const serialized = JSON.stringify(sortKeys(schema));
+    return crypto.createHash("sha256").update(serialized).digest("hex");
+}
+exports.computeSchemaHash = computeSchemaHash;

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

@@ -0,0 +1,19 @@
+/**
+ * Spinner Utility
+ *
+ * Thin wrapper around `ora` for consistent spinner behavior.
+ * Respects the noColor config setting.
+ */
+interface SpinnerInstance {
+    start(text?: string): SpinnerInstance;
+    stop(): SpinnerInstance;
+    succeed(text?: string): SpinnerInstance;
+    fail(text?: string): SpinnerInstance;
+    text: string;
+}
+/**
+ * Create a spinner that respects noColor config.
+ * Falls back to simple log messages if ora is not available.
+ */
+export declare function createSpinner(text: string): Promise<SpinnerInstance>;
+export {};

package/dist/lib/utils/spinner.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * Spinner Utility
+ *
+ * Thin wrapper around `ora` for consistent spinner behavior.
+ * Respects the noColor config setting.
+ */
+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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSpinner = void 0;
+const config_1 = require("../config");
+/**
+ * Create a spinner that respects noColor config.
+ * Falls back to simple log messages if ora is not available.
+ */
+async function createSpinner(text) {
+    const config = config_1.globalConfig.read();
+    try {
+        // Dynamic import to keep ora optional at startup
+        const ora = (await Promise.resolve().then(() => __importStar(require("ora")))).default;
+        const spinner = ora({
+            text,
+            color: config.noColor ? undefined : "cyan",
+            isSilent: false,
+        });
+        return spinner;
+    }
+    catch {
+        // Fallback: simple text output when ora is not installed
+        return createFallbackSpinner(text);
+    }
+}
+exports.createSpinner = createSpinner;
+/**
+ * Fallback spinner that uses plain text output.
+ */
+function createFallbackSpinner(initialText) {
+    let currentText = initialText;
+    const instance = {
+        get text() {
+            return currentText;
+        },
+        set text(value) {
+            currentText = value;
+        },
+        start(text) {
+            if (text)
+                currentText = text;
+            console.log(`  ${currentText}...`);
+            return instance;
+        },
+        stop() {
+            return instance;
+        },
+        succeed(text) {
+            console.log(`  ${text || currentText}`);
+            return instance;
+        },
+        fail(text) {
+            console.log(`  ${text || currentText}`);
+            return instance;
+        },
+    };
+    return instance;
+}

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

@@ -0,0 +1,12 @@
+import { TargetLanguage } from "../types";
+export declare const TEMPLATE_REPOS: Record<TargetLanguage, string>;
+export declare const PROJECT_NAME_PATTERN: RegExp;
+/**
+ * Clone a template repository into the given project path.
+ * Removes the .git directory after cloning.
+ */
+export declare function cloneTemplate(projectPath: string, language: TargetLanguage, log: (msg: string) => void): void;
+/**
+ * Initialize a fresh git repository in the given directory.
+ */
+export declare function initGitRepo(projectPath: string): void;

package/dist/lib/utils/template.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initGitRepo = exports.cloneTemplate = exports.PROJECT_NAME_PATTERN = exports.TEMPLATE_REPOS = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+const shelljs_1 = tslib_1.__importDefault(require("shelljs"));
+exports.TEMPLATE_REPOS = {
+    typescript: "https://github.com/apsoai/service-template.git",
+    python: "https://github.com/apsoai/service-template-python.git",
+    go: "https://github.com/apsoai/service-template-go.git",
+};
+exports.PROJECT_NAME_PATTERN = /^[A-Za-z][\w-]*$/;
+/**
+ * Clone a template repository into the given project path.
+ * Removes the .git directory after cloning.
+ */
+function cloneTemplate(projectPath, language, log) {
+    const repoUrl = exports.TEMPLATE_REPOS[language];
+    log(`Cloning ${language} service template...`);
+    if (fs.existsSync(projectPath)) {
+        throw new Error(`Directory already exists: ${projectPath}`);
+    }
+    try {
+        fs.mkdirSync(projectPath, { recursive: true });
+    }
+    catch (error) {
+        throw new Error(`Failed to create directory: ${error.message}`);
+    }
+    const cloneResult = shelljs_1.default.exec(`git clone --depth=1 --branch=main "${repoUrl}" "${projectPath}"`, { silent: true });
+    if (cloneResult.code !== 0) {
+        shelljs_1.default.rm("-rf", projectPath);
+        throw new Error(`Failed to clone the template repository from GitHub.\n` +
+            `Error Output:\n${cloneResult.stderr}\n\n` +
+            `Please check your network connection and ensure the repository exists at ${repoUrl}`);
+    }
+    shelljs_1.default.rm("-rf", path.join(projectPath, ".git"));
+}
+exports.cloneTemplate = cloneTemplate;
+/**
+ * Initialize a fresh git repository in the given directory.
+ */
+function initGitRepo(projectPath) {
+    const result = shelljs_1.default.exec(`git init "${projectPath}"`, { silent: true });
+    if (result.code !== 0) {
+        throw new Error(`Failed to initialize git repository: ${result.stderr}`);
+    }
+}
+exports.initGitRepo = initGitRepo;