@ollie-shop/cli 0.2.0 → 0.3.0

package/dist/commands/function.js

@@ -0,0 +1,243 @@
+"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.registerFunctionCommands = registerFunctionCommands;
+const functionActions = __importStar(require("../actions/function.actions"));
+const command_schema_1 = require("../schemas/command.schema");
+const command_builder_1 = require("../utils/command-builder");
+const command_parser_1 = require("../utils/command-parser");
+function registerFunctionCommands(program) {
+    const cmd = (0, command_builder_1.buildCommandGroup)(program, "function", "Manage Ollie Shop functions", ["func"]);
+    // Create function command
+    (0, command_builder_1.buildCommand)(cmd, {
+        name: "create",
+        description: "Create a new function",
+        options: [
+            command_parser_1.COMMON_OPTIONS.functionName,
+            command_parser_1.COMMON_OPTIONS.functionInvocation,
+            command_parser_1.COMMON_OPTIONS.priority,
+            {
+                flags: "--on-error <strategy>",
+                description: "Error handling strategy (throw|skip)",
+                defaultValue: "throw",
+            },
+            {
+                flags: "-d, --description <description>",
+                description: "Function description",
+            },
+            {
+                flags: "--template <template>",
+                description: "Function template to use",
+            },
+            command_parser_1.COMMON_OPTIONS.tests,
+            command_parser_1.COMMON_OPTIONS.noTests,
+        ],
+        schema: command_schema_1.FunctionCreateOptionsSchema,
+        examples: [
+            {
+                description: "Create a function to validate orders",
+                command: "ollieshop function create --name validate-order --event order --timing before",
+            },
+            {
+                description: "Create a discount function for cart",
+                command: "ollieshop function create --name apply-discount --event cart --description 'Apply bulk discounts'",
+            },
+            {
+                description: "Create a JavaScript function without tests",
+                command: "ollieshop function create --name check-inventory --language javascript --no-tests",
+            },
+        ],
+        handler: async (options, console) => {
+            await functionActions.createFunction(options, console);
+        },
+    });
+    // Validate function command
+    (0, command_builder_1.buildCommand)(cmd, {
+        name: "validate",
+        description: "Validate a function",
+        options: [command_parser_1.COMMON_OPTIONS.path],
+        schema: command_schema_1.FunctionValidateOptionsSchema,
+        examples: [
+            {
+                description: "Validate current directory",
+                command: "ollieshop function validate",
+            },
+            {
+                description: "Validate specific function",
+                command: "ollieshop function validate --path ./functions/validate-order",
+            },
+        ],
+        handler: async (options, console) => {
+            await functionActions.validateFunction({
+                path: options.path || process.cwd(),
+                strict: options.strict ?? false,
+                fix: options.fix ?? false,
+            }, console);
+        },
+    });
+    // Test function command
+    (0, command_builder_1.buildCommand)(cmd, {
+        name: "test",
+        description: "Test a function locally",
+        options: [
+            command_parser_1.COMMON_OPTIONS.path,
+            {
+                flags: "-w, --watch",
+                description: "Watch for changes",
+                defaultValue: false,
+            },
+            {
+                flags: "--payload <json>",
+                description: "Test payload (JSON string)",
+            },
+            {
+                flags: "--timeout <ms>",
+                description: "Timeout in milliseconds",
+            },
+        ],
+        schema: command_schema_1.FunctionTestOptionsSchema,
+        examples: [
+            {
+                description: "Test function in current directory",
+                command: "ollieshop function test",
+            },
+            {
+                description: "Test with custom payload",
+                command: `ollieshop function test --payload '{"items": [{"id": "123", "quantity": 2}]}'`,
+            },
+            {
+                description: "Test in watch mode",
+                command: "ollieshop function test --watch",
+            },
+        ],
+        handler: async (options, console) => {
+            await functionActions.testFunction({
+                path: options.path || process.cwd(),
+                payload: options.payload,
+                timeout: options.timeout,
+                watch: options.watch ?? false,
+                coverage: options.coverage ?? false,
+            }, console);
+        },
+    });
+    // Deploy function command
+    (0, command_builder_1.buildCommand)(cmd, {
+        name: "deploy",
+        description: "Build and deploy a function to cloud",
+        options: [
+            command_parser_1.COMMON_OPTIONS.path,
+            {
+                flags: "--id <id>",
+                description: "Function ID for deployment",
+                required: true,
+            },
+            command_parser_1.COMMON_OPTIONS.wait,
+        ],
+        schema: command_schema_1.FunctionDeployOptionsSchema,
+        examples: [
+            {
+                description: "Deploy current directory",
+                command: "ollieshop function deploy",
+            },
+            {
+                description: "Deploy specific function and wait",
+                command: "ollieshop function deploy --path ./my-function --wait",
+            },
+            {
+                description: "Deploy with function ID",
+                command: "ollieshop function deploy --id func_123abc",
+            },
+        ],
+        handler: async (options, console) => {
+            // Map id to functionId if provided
+            const deployOptions = {
+                path: options.path || process.cwd(),
+                functionId: options.id || options.functionId,
+                wait: options.wait,
+            };
+            await functionActions.deployFunction(deployOptions, console);
+        },
+    });
+    // List functions command
+    (0, command_builder_1.buildCommand)(cmd, {
+        name: "list",
+        description: "List all functions",
+        aliases: ["ls"],
+        examples: [
+            {
+                description: "List all functions",
+                command: "ollieshop function list",
+            },
+        ],
+        handler: async (_, console) => {
+            await functionActions.listFunctions(console);
+        },
+    });
+    // Deploy status command
+    cmd
+        .command("deploy-status <buildId>")
+        .description("Check the status of a function deployment")
+        .action(async (buildId) => {
+        try {
+            const { getBuildStatus } = await import("@ollie-shop/core");
+            const { console: cliConsole } = await import("../utils/console.js");
+            const spinner = cliConsole.spinner("Checking deployment status...");
+            const build = await getBuildStatus(buildId);
+            if (!build) {
+                spinner.fail("Build not found");
+                return;
+            }
+            spinner.succeed();
+            cliConsole.info("Deployment Status:");
+            cliConsole.log(`  Build ID: ${build.id}`);
+            cliConsole.log(`  Status: ${build.status}`);
+            cliConsole.log(`  Started: ${new Date(build.startTime).toLocaleString()}`);
+            if (build.endTime) {
+                cliConsole.log(`  Completed: ${new Date(build.endTime).toLocaleString()}`);
+            }
+            if (build.deploymentUrl) {
+                cliConsole.success(`\nFunction URL: ${build.deploymentUrl}`);
+            }
+            if (build.error) {
+                cliConsole.error(`\nError: ${build.error}`);
+            }
+        }
+        catch (error) {
+            const { console: cliConsole } = await import("../utils/console.js");
+            cliConsole.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/help.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from "@commander-js/extra-typings";
+export declare function configureHelpCommand(program: Command): void;
+//# sourceMappingURL=help.d.ts.map

package/dist/commands/help.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"help.d.ts","sourceRoot":"","sources":["../../src/commands/help.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAG3D,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAc3D"}

package/dist/commands/help.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureHelpCommand = configureHelpCommand;
+const console_1 = require("../utils/console");
+function configureHelpCommand(program) {
+    program
+        .command("help [command]")
+        .description("Display help for a specific command or list all commands")
+        .action((cmdName) => {
+        if (cmdName) {
+            // For specific command help, show the program help with the command
+            console_1.console.info(`\nHelp for command: ${cmdName}`);
+            console_1.console.info("Use 'ollieshop <command> --help' for detailed help\n");
+        }
+        else {
+            // Show general help
+            program.help();
+        }
+    });
+}

package/dist/commands/index.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from "@commander-js/extra-typings";
+export declare function registerCommands(program: Command): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/commands/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAW3D,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAevD"}

package/dist/commands/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCommands = registerCommands;
+const component_1 = require("./component");
+const docs_1 = require("./docs");
+const function_1 = require("./function");
+const help_1 = require("./help");
+const login_1 = require("./login");
+const project_1 = require("./project");
+const store_version_1 = require("./store-version");
+const version_1 = require("./version");
+const whoami_1 = require("./whoami");
+function registerCommands(program) {
+    // Register simple commands that don't need heavy services
+    (0, docs_1.configureDocsCommand)(program);
+    (0, help_1.configureHelpCommand)(program);
+    (0, login_1.configureLoginCommand)(program);
+    (0, whoami_1.configureWhoamiCommand)(program);
+    // Register new commands
+    (0, store_version_1.registerStoreVersionCommands)(program);
+    (0, version_1.configureVersionCommand)(program);
+    // Register complex commands with lazy service loading
+    (0, component_1.registerComponentCommands)(program);
+    (0, function_1.registerFunctionCommands)(program);
+    (0, project_1.registerProjectCommands)(program);
+}

package/dist/commands/login.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from "@commander-js/extra-typings";
+export declare function configureLoginCommand(program: Command): Command;
+//# sourceMappingURL=login.d.ts.map

package/dist/commands/login.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"login.d.ts","sourceRoot":"","sources":["../../src/commands/login.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAO3D,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CA+B/D"}

package/dist/commands/login.js

@@ -0,0 +1,175 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureLoginCommand = configureLoginCommand;
+const node_crypto_1 = require("node:crypto");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_http_1 = require("node:http");
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+const types_1 = require("../types");
+const console_1 = require("../utils/console");
+const DEFAULT_CALLBACK_PORT = 7777;
+const AUTH_ENDPOINT = "https://admin.ollie.shop/auth/login";
+function configureLoginCommand(program) {
+    return program
+        .command("login")
+        .description("Log in to your Ollie Shop account")
+        .option("-p, --port <port>", "Port to use for the local callback server", DEFAULT_CALLBACK_PORT.toString())
+        .option("--auth-url <url>", "Custom authorization URL", AUTH_ENDPOINT)
+        .action(async (options) => {
+        console_1.console.info("🔐 Initiating Ollie Shop login flow...");
+        try {
+            const token = await startWebAuthFlow(options);
+            if (token) {
+                await saveCredentials(token);
+                console_1.console.success("✅ Successfully logged in!");
+                return;
+            }
+            console_1.console.error("❌ Authentication failed. Please try again.");
+            process.exit(1);
+        }
+        catch (error) {
+            console_1.console.error(`❌ Login failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+            process.exit(1);
+        }
+    });
+}
+async function handleAuthCallback(req, res, state, resolve, reject) {
+    const socket = req.socket;
+    const url = new URL(req.url || "/", `http://localhost:${socket.localPort || 3000}`);
+    const params = url.searchParams;
+    const returnedState = params.get("state");
+    if (returnedState !== state) {
+        sendErrorResponse(res, 400, "Invalid state parameter", "Authentication failed. Please try again.");
+        reject(new Error("Invalid state parameter"));
+        return;
+    }
+    let formData = "";
+    req.on("data", (chunk) => {
+        formData += chunk.toString();
+    });
+    await new Promise((formResolve) => {
+        req.on("end", () => {
+            formResolve();
+        });
+    });
+    const formParams = new URLSearchParams(formData);
+    const accessToken = formParams.get("access_token");
+    const refreshToken = formParams.get("refresh_token") || "";
+    const expiresAt = formParams.get("expires_at") ||
+        new Date(Date.now() + 3600000).toISOString();
+    if (!accessToken) {
+        sendErrorResponse(res, 400, "Missing authentication token", "Authentication failed. Please try again.");
+        reject(new Error("Missing authentication token"));
+        return;
+    }
+    try {
+        const token = {
+            accessToken,
+            refreshToken,
+            expiresAt,
+        };
+        sendSuccessResponse(res);
+        resolve(token);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        sendErrorResponse(res, 500, "Authentication failed", `Error: ${errorMessage}`);
+        reject(new Error(errorMessage));
+    }
+}
+function sendErrorResponse(res, statusCode, title, message) {
+    res.writeHead(statusCode, { "Content-Type": "text/html" });
+    res.end(`<h1>${title}</h1><p>${message}</p>`);
+}
+function sendSuccessResponse(res) {
+    res.writeHead(200, { "Content-Type": "text/html" });
+    res.end("<h1>Authentication successful!</h1><p>You can now close this window and return to the CLI.</p>");
+}
+function sendWaitingResponse(res) {
+    res.writeHead(200, { "Content-Type": "text/html" });
+    res.end("<h1>Ollie Shop CLI Authentication</h1><p>Waiting for authentication response...</p>");
+}
+async function startWebAuthFlow(options) {
+    const state = (0, node_crypto_1.randomBytes)(16).toString("hex");
+    const port = Number.parseInt(options.port, 10);
+    const baseUrl = options.authUrl;
+    return new Promise((resolve, reject) => {
+        const server = (0, node_http_1.createServer)(async (req, res) => {
+            try {
+                const url = new URL(req.url || "/", `http://localhost:${port}`);
+                if (url.pathname === "/callback") {
+                    await handleAuthCallback(req, res, state, (token) => {
+                        server.close(() => {
+                            console_1.console.debug("🔐 Local authentication server closed");
+                            resolve(token);
+                        });
+                    }, (error) => {
+                        server.close(() => {
+                            console_1.console.debug("🔐 Local authentication server closed");
+                            reject(error);
+                        });
+                    });
+                }
+                else {
+                    sendWaitingResponse(res);
+                }
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : "Unknown error";
+                sendErrorResponse(res, 500, "Server Error", errorMessage);
+                server.close(() => {
+                    console_1.console.debug("🔐 Local authentication server closed");
+                    reject(new Error(errorMessage));
+                });
+            }
+        });
+        server.listen(port, async () => {
+            const redirectUrl = `http://localhost:${port}/callback`;
+            const authUrl = new URL(baseUrl);
+            authUrl.searchParams.set("flow", "cli");
+            authUrl.searchParams.set("state", state);
+            authUrl.searchParams.set("redirect_to", redirectUrl);
+            console_1.console.info("\n🔒 Please authenticate in your browser...\n");
+            console_1.console.info(`Opening: ${authUrl}\n`);
+            const open = (await import("open")).default;
+            open(authUrl.toString());
+        });
+        server.on("error", (err) => {
+            if ((0, types_1.isNodeError)(err) && err.code === "EADDRINUSE") {
+                reject(new Error(`Port ${port} is already in use. Please specify a different port using the --port option.`));
+            }
+            else {
+                reject(err);
+            }
+            server.close();
+        });
+        const timeoutId = setTimeout(() => {
+            server.close(() => {
+                console_1.console.debug("🔐 Local authentication server closed due to timeout");
+                reject(new Error("Authentication timed out. Please try again."));
+            });
+        }, 5 * 60 * 1000);
+        server.on("close", () => {
+            clearTimeout(timeoutId);
+        });
+    });
+}
+async function saveCredentials(token) {
+    console_1.console.debug("Saving credentials...");
+    const configDir = node_path_1.default.join((0, node_os_1.homedir)(), ".ollie-shop");
+    const credentialsPath = node_path_1.default.join(configDir, "credentials.json");
+    try {
+        await promises_1.default.mkdir(configDir, { recursive: true });
+    }
+    catch (error) {
+        if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) {
+            throw error;
+        }
+    }
+    await promises_1.default.writeFile(credentialsPath, JSON.stringify(token, null, 2));
+    return true;
+}

package/dist/commands/project.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from "@commander-js/extra-typings";
+export declare function registerProjectCommands(program: Command): void;
+//# sourceMappingURL=project.d.ts.map

package/dist/commands/project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../src/commands/project.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAS3D,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAiG9D"}

package/dist/commands/project.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerProjectCommands = registerProjectCommands;
+const project_actions_1 = require("../actions/project.actions");
+const console_1 = require("../utils/console");
+function registerProjectCommands(program) {
+    const projectCommand = program
+        .command("project")
+        .description("Project management commands");
+    projectCommand
+        .command("init")
+        .description("Initialize a new project")
+        .option("-n, --name <name>", "Project name")
+        .option("-t, --template <template>", "Project template")
+        .action(async (options) => {
+        try {
+            await (0, project_actions_1.initProject)({
+                name: options.name,
+                template: options.template || "default",
+                git: true,
+                install: true,
+            }, console_1.console);
+        }
+        catch (error) {
+            console_1.console.error(error instanceof Error ? error.message : "An error occurred");
+            process.exit(1);
+        }
+    });
+    projectCommand
+        .command("build")
+        .description("Build project")
+        .option("-p, --path <path>", "Project path")
+        .option("--watch", "Watch for changes")
+        .action(async (options) => {
+        try {
+            await (0, project_actions_1.buildProject)({
+                path: options.path,
+                watch: options.watch ?? false,
+            }, console_1.console);
+        }
+        catch (error) {
+            console_1.console.error(error instanceof Error ? error.message : "An error occurred");
+            process.exit(1);
+        }
+    });
+    projectCommand
+        .command("dev")
+        .description("Start development server")
+        .option("-p, --port <port>", "Port number", Number.parseInt)
+        .option("--open", "Open browser")
+        .action(async (options) => {
+        try {
+            await (0, project_actions_1.startDevServer)({
+                port: options.port ?? 3000,
+                open: options.open ?? false,
+            }, console_1.console);
+        }
+        catch (error) {
+            console_1.console.error(error instanceof Error ? error.message : "An error occurred");
+            process.exit(1);
+        }
+    });
+    projectCommand
+        .command("validate")
+        .description("Validate project")
+        .option("-p, --path <path>", "Project path")
+        .action(async (options) => {
+        try {
+            await (0, project_actions_1.validateProject)({
+                path: options.path,
+            }, console_1.console);
+        }
+        catch (error) {
+            console_1.console.error(error instanceof Error ? error.message : "An error occurred");
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/store-version.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from "@commander-js/extra-typings";
+export declare function registerStoreVersionCommands(program: Command): void;
+//# sourceMappingURL=store-version.d.ts.map

package/dist/commands/store-version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-version.d.ts","sourceRoot":"","sources":["../../src/commands/store-version.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAkB3D,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA+NnE"}