@ketrics/ketrics-cli 0.3.0 → 0.4.0

package/dist/src/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.3.0";
+export declare const VERSION = "0.4.0";
 //# sourceMappingURL=version.d.ts.map

package/dist/src/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
 // Auto-generated - do not edit
-exports.VERSION = "0.3.0";
+exports.VERSION = "0.4.0";
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ketrics/ketrics-cli",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "CLI tool for deploying applications to Ketrics platform",
   "main": "dist/index.js",
   "bin": {

package/templates/HelloWorld/frontend/src/mocks/handlers.ts

@@ -0,0 +1,149 @@
+/**
+ * Mock Backend Handlers
+ *
+ * Define mock responses for your backend functions here.
+ * These are used automatically when running `npm run dev` (local development)
+ * and are completely excluded from production builds.
+ *
+ * Each key corresponds to a backend function name exported from backend/src/index.ts.
+ * The handler receives the same payload your backend function would receive
+ * and should return the same response shape.
+ *
+ * Usage:
+ *   1. Add a handler for each backend function you want to mock
+ *   2. Run `npm run dev` - the frontend will use these handlers instead of the runtime API
+ *   3. Run `npm run build` / `ketrics deploy` - mock code is stripped out entirely
+ */
+
+type MockHandler = (payload?: unknown) => unknown | Promise<unknown>;
+
+const handlers: Record<string, MockHandler> = {
+  echo: (payload) => ({
+    payload,
+    context: {
+      tenant: { id: "mock-tenant-id", code: "mock-tenant", name: "Mock Tenant" },
+      application: { id: "mock-app-id", code: "mock-app", name: "Mock App", version: "1.0.0", deploymentId: "mock-deploy" },
+      requestor: { type: "user", userId: "mock-user-id", email: "dev@localhost", name: "Local Developer", applicationPermissions: [] },
+      runtime: { nodeVersion: "18.x", runtime: "mock", region: "local" },
+      environment: {},
+    },
+  }),
+
+  info: () => ({
+    tenant: { id: "mock-tenant-id", code: "mock-tenant", name: "Mock Tenant" },
+    application: { id: "mock-app-id", code: "mock-app", name: "Mock App", version: "1.0.0" },
+    runtime: { nodeVersion: "18.x", runtime: "mock", region: "local" },
+  }),
+
+  fetchExternalApi: () => ({
+    data: { id: 1, title: "Mock Post", body: "This is a mock response from the local dev server." },
+    fetchedAt: new Date().toISOString(),
+  }),
+
+  // --- Volumes ---
+
+  saveFile: () => ({
+    jsonFile: { key: "output/data.json", etag: "mock-etag-1", size: 128 },
+    textFile: { key: "output/hello.txt", etag: "mock-etag-2", size: 19 },
+  }),
+
+  readFile: () => ({
+    contentType: "application/json",
+    contentLength: 128,
+    lastModified: new Date().toISOString(),
+    parsed: { generatedBy: "mock-app", generatedAt: new Date().toISOString(), tenant: "mock-tenant" },
+  }),
+
+  listFiles: (payload: unknown) => {
+    const { prefix } = (payload as { prefix?: string }) || {};
+    return {
+      files: [
+        { key: `${prefix || "output/"}data.json`, size: 128, lastModified: new Date().toISOString(), contentType: "application/json" },
+        { key: `${prefix || "output/"}hello.txt`, size: 19, lastModified: new Date().toISOString(), contentType: "text/plain" },
+      ],
+      count: 2,
+      isTruncated: false,
+    };
+  },
+
+  generateDownloadUrl: () => ({
+    url: "https://example.com/mock-download-url",
+    expiresAt: new Date(Date.now() + 3600_000).toISOString(),
+  }),
+
+  copyFile: () => ({
+    sourceKey: "output/data.json",
+    destinationKey: "backup/data-backup.json",
+    etag: "mock-etag-copy",
+  }),
+
+  // --- Database ---
+
+  queryUsers: (payload: unknown) => {
+    const { limit } = (payload as { limit?: number }) || {};
+    const users = [
+      { id: 1, name: "Alice Johnson", email: "alice@example.com" },
+      { id: 2, name: "Bob Smith", email: "bob@example.com" },
+      { id: 3, name: "Carol Davis", email: "carol@example.com" },
+      { id: 4, name: "Dan Wilson", email: "dan@example.com" },
+      { id: 5, name: "Eve Martinez", email: "eve@example.com" },
+    ];
+    const sliced = users.slice(0, limit || 10);
+    return { users: sliced, rowCount: sliced.length };
+  },
+
+  insertRecord: (payload: unknown) => {
+    const { name, email } = (payload as { name?: string; email?: string }) || {};
+    if (!name || !email) throw new Error("name and email are required");
+    return { affectedRows: 1, insertId: Math.floor(Math.random() * 1000) + 100 };
+  },
+
+  transferFunds: (payload: unknown) => {
+    const { amount } = (payload as { amount?: number }) || {};
+    if (!amount || amount <= 0) throw new Error("Amount must be positive");
+    return { transferred: amount };
+  },
+
+  // --- Documents ---
+
+  createSimplePdf: () => ({
+    downloadUrl: "https://example.com/mock-simple.pdf",
+    message: "[Mock] PDF would be generated by the backend",
+  }),
+
+  createInvoicePdf: () => ({
+    downloadUrl: "https://example.com/mock-invoice.pdf",
+    message: "[Mock] Invoice PDF would be generated by the backend",
+  }),
+
+  createSpreadsheet: () => ({
+    downloadUrl: "https://example.com/mock-spreadsheet.xlsx",
+    message: "[Mock] Spreadsheet would be generated by the backend",
+  }),
+
+  exportDataToExcel: () => ({
+    downloadUrl: "https://example.com/mock-export.xlsx",
+    message: "[Mock] Excel export would be generated by the backend",
+  }),
+
+  // --- Messaging & Jobs ---
+
+  sendNotification: (payload: unknown) => {
+    const { subject, body } = (payload as { subject?: string; body?: string }) || {};
+    return { sent: true, subject, body, message: "[Mock] Notification would be sent by the backend" };
+  },
+
+  scheduleBackgroundJob: () => ({
+    jobId: `mock-job-${Date.now()}`,
+    status: "scheduled",
+    message: "[Mock] Job would be scheduled by the backend",
+  }),
+
+  getSecret: () => ({
+    value: "mock-secret-value",
+    message: "[Mock] Secret would be retrieved from the backend",
+  }),
+};
+
+export { handlers };
+export type { MockHandler };

package/templates/HelloWorld/frontend/src/mocks/mock-client.ts

@@ -0,0 +1,45 @@
+/**
+ * Mock API Client
+ *
+ * Replaces the real API client during local development (`npm run dev`).
+ * Routes function calls to the mock handlers defined in ./handlers.ts
+ * instead of making HTTP requests to the Ketrics Runtime API.
+ *
+ * This file is tree-shaken out of production builds by Vite.
+ */
+
+import { handlers } from "./handlers";
+
+class MockAPIClient {
+  async run(fnName: string, payload?: unknown) {
+    const handler = handlers[fnName];
+
+    if (!handler) {
+      throw new Error(
+        `[Mock] No handler defined for "${fnName}". ` +
+        `Add it to src/mocks/handlers.ts to use it in local development.`
+      );
+    }
+
+    // Simulate network latency
+    await new Promise((resolve) => setTimeout(resolve, 200));
+
+    try {
+      const result = await handler(payload);
+      console.log(`[Mock] ${fnName}`, { payload, result });
+      return { success: true, result };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`[Mock] ${fnName} error:`, message);
+      throw new Error(message);
+    }
+  }
+}
+
+export function createMockClient() {
+  console.log(
+    "%c[Ketrics] Running with mock backend — edit src/mocks/handlers.ts to customize responses",
+    "color: #f59e0b; font-weight: bold;"
+  );
+  return new MockAPIClient();
+}

package/templates/HelloWorld/frontend/src/services/index.ts

@@ -1,19 +1,16 @@
 import { createAuthManager } from "@ketrics/sdk-frontend";
 
-const auth = createAuthManager();
-
-// Initialize auto-refresh
-auth.initAutoRefresh({
-  refreshBuffer: 60,
-  onTokenUpdated: () => {
-    // Token is refreshed automatically and retrieved via getAccessToken()
-  },
-});
+interface APIClientInterface {
+  run(fnName: string, payload?: unknown): Promise<unknown>;
+}
 
-class APIClient {
+// ---------------------------------------------------------------------------
+// Real API Client — used when deployed (production builds)
+// ---------------------------------------------------------------------------
+class APIClient implements APIClientInterface {
   private auth;
 
-  constructor(authManager: typeof auth) {
+  constructor(authManager: ReturnType<typeof createAuthManager>) {
     this.auth = authManager;
   }
 
@@ -50,6 +47,27 @@ class APIClient {
   }
 }
 
-const apiClient = new APIClient(auth);
+// ---------------------------------------------------------------------------
+// Client initialization — mock in dev, real in production
+// ---------------------------------------------------------------------------
+async function createClient(): Promise<APIClientInterface> {
+  if (import.meta.env.DEV) {
+    // Dynamic import keeps mock code in a separate chunk that Vite
+    // completely excludes from production builds.
+    const { createMockClient } = await import("../mocks/mock-client");
+    return createMockClient();
+  }
+
+  const auth = createAuthManager();
+  auth.initAutoRefresh({
+    refreshBuffer: 60,
+    onTokenUpdated: () => {
+      // Token is refreshed automatically and retrieved via getAccessToken()
+    },
+  });
+  return new APIClient(auth);
+}
+
+const apiClient = await createClient();
 
 export { apiClient };

package/templates/HelloWorld/frontend/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />