@ductape/cli 0.2.0

package/src/lib/snippets.ts

@@ -0,0 +1,165 @@
+const ALLOWED_SNIPPET_METHODS: Record<string, string[]> = {
+  action: ['run', 'dispatch', 'execute'],
+  workflow: ['run', 'dispatch', 'execute'],
+  database: ['dispatch', 'find', 'insert', 'update', 'delete', 'query', 'upsert', 'count', 'aggregate'],
+  graph: ['dispatch', 'find', 'insert', 'update', 'delete', 'query', 'execute'],
+  vector: ['query', 'find', 'findSimilar', 'upsert', 'insert', 'delete', 'dispatch'],
+  storage: ['dispatch', 'upload', 'download', 'remove', 'listFiles', 'getSignedUrl', 'stats'],
+  notification: ['dispatch', 'send', 'email.send', 'push.send', 'sms.send', 'callback.send'],
+  messaging: ['dispatch', 'send', 'publish', 'produce', 'consume'],
+  broker: ['dispatch', 'send', 'publish', 'produce', 'consume'],
+  quota: ['run', 'dispatch', 'check', 'consume'],
+  fallback: ['run', 'dispatch'],
+  healthcheck: ['run', 'check', 'status'],
+  health: ['run', 'check', 'status'],
+  session: ['start', 'verify', 'refresh', 'revoke', 'listActive'],
+  cache: ['get', 'set', 'clear', 'clearAll', 'dispatch', 'fetchValues'],
+};
+
+export function ensureSupportedSnippetOperation(operationFamily: string, method: string): void {
+  const family = operationFamily.toLowerCase();
+  const allowed = ALLOWED_SNIPPET_METHODS[family] ?? [];
+  if (!allowed.includes(method)) {
+    throw new Error(
+      `Unsupported snippet operation "${family}.${method}". Allowed: ${allowed.join(', ') || '(none)'}`,
+    );
+  }
+}
+
+function resolveSdkCallPath(operationFamily: string, method: string): string {
+  const family = operationFamily.toLowerCase();
+  const m = method.toLowerCase();
+
+  if (family === 'action') return `actions.${m}`;
+  if (family === 'workflow') return `workflows.${m}`;
+  if (family === 'database') return m === 'dispatch' ? 'databases.dispatch' : `databases.${m}`;
+  if (family === 'graph') return m === 'dispatch' ? 'graph.dispatch' : `graph.${m}`;
+  if (family === 'vector') return `vector.${m}`;
+  if (family === 'storage') return m === 'dispatch' ? 'storage.dispatch' : `storage.${m}`;
+  if (family === 'notification') return m === 'dispatch' ? 'notifications.dispatch' : `notifications.${m}`;
+  if (family === 'messaging' || family === 'broker') {
+    if (m === 'dispatch') return 'messageBrokers.dispatch';
+    if (m === 'send' || m === 'publish' || m === 'produce') return 'messageBrokers.produce';
+    return `messageBrokers.${m}`;
+  }
+  if (family === 'quota') return `quotas.${m}`;
+  if (family === 'fallback') return `fallback.${m}`;
+  if (family === 'healthcheck' || family === 'health') return `health.${m}`;
+  if (family === 'session') return `sessions.${m}`;
+  if (family === 'cache') return (m === 'dispatch' ? 'caches.dispatch' : `caches.${m}`);
+  return `${family}.${m}`;
+}
+
+function buildInvocationArgs(payload: Record<string, unknown>): Record<string, unknown> {
+  const input = (payload.input as Record<string, unknown>) ?? {};
+  return {
+    product: payload.product_tag,
+    env: payload.env,
+    ...input,
+    ...(payload.session ? { session: payload.session } : {}),
+    ...(payload.cache ? { cache: payload.cache } : {}),
+  };
+}
+
+function prettyJson(v: unknown): string {
+  return JSON.stringify(v ?? {}, null, 2);
+}
+
+export function buildTypeScriptSnippet(
+  payload: Record<string, unknown>,
+  operationFamily: string,
+  method: string,
+): string {
+  const callPath = resolveSdkCallPath(operationFamily, method);
+  const args = buildInvocationArgs(payload);
+  return `import Ductape from '@ductape/sdk';
+
+const ductape = new Ductape({
+  publishableKey: process.env.DUCTAPE_PUBLISHABLE_KEY!,
+  product: process.env.DUCTAPE_PRODUCT!,
+  env: process.env.DUCTAPE_ENV!,
+});
+
+async function main() {
+  const result = await ductape.${callPath}(${prettyJson(args)});
+  console.log(JSON.stringify(result, null, 2));
+}
+
+main().catch(console.error);
+`;
+}
+
+export function buildPythonSnippet(
+  payload: Record<string, unknown>,
+  operationFamily: string,
+  method: string,
+): string {
+  const callPath = resolveSdkCallPath(operationFamily, method).replace(/\./g, '_');
+  const args = buildInvocationArgs(payload);
+  return `import os
+import json
+from ductape import Ductape
+
+ductape = Ductape(
+    publishable_key=os.environ["DUCTAPE_PUBLISHABLE_KEY"],
+    product=os.environ["DUCTAPE_PRODUCT"],
+    env=os.environ["DUCTAPE_ENV"],
+)
+
+def main():
+    args = ${prettyJson(args)}
+    result = ductape.${callPath}(args)
+    print(json.dumps(result, indent=2))
+
+if __name__ == "__main__":
+    main()
+`;
+}
+
+export function buildGoSnippet(
+  payload: Record<string, unknown>,
+  operationFamily: string,
+  method: string,
+): string {
+  const callPath = resolveSdkCallPath(operationFamily, method);
+  return `package main
+
+// go get github.com/ductape/ductape/sdk/go
+// See https://docs.ductape.app for ${operationFamily}.${method}
+// Payload preview:
+// ${prettyJson(payload).split('\n').join('\n// ')}
+func main() {
+    // ductape.${callPath}(...)
+}
+`;
+}
+
+export function buildDotnetSnippet(
+  payload: Record<string, unknown>,
+  operationFamily: string,
+  method: string,
+): string {
+  const callPath = resolveSdkCallPath(operationFamily, method);
+  return `// dotnet add package Ductape.Sdk
+// Operation: ${operationFamily}.${method} -> ${callPath}
+// Payload: ${JSON.stringify(payload)}
+`;
+}
+
+export function buildSnippet(
+  language: 'typescript' | 'python' | 'go' | 'dotnet',
+  payload: Record<string, unknown>,
+  operationFamily: string,
+  method: string,
+): string {
+  switch (language) {
+    case 'python':
+      return buildPythonSnippet(payload, operationFamily, method);
+    case 'go':
+      return buildGoSnippet(payload, operationFamily, method);
+    case 'dotnet':
+      return buildDotnetSnippet(payload, operationFamily, method);
+    default:
+      return buildTypeScriptSnippet(payload, operationFamily, method);
+  }
+}

package/src/lib/templates.ts

@@ -0,0 +1,78 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const TEMPLATES_ROOT = path.resolve(__dirname, '../../templates');
+
+export type InitLanguage = 'typescript' | 'python' | 'go' | 'dotnet' | 'unknown';
+
+export function detectLanguage(dir: string): InitLanguage {
+  if (fs.existsSync(path.join(dir, 'package.json'))) return 'typescript';
+  if (fs.existsSync(path.join(dir, 'pyproject.toml')) || fs.existsSync(path.join(dir, 'requirements.txt'))) {
+    return 'python';
+  }
+  if (fs.existsSync(path.join(dir, 'go.mod'))) return 'go';
+  try {
+    if (fs.readdirSync(dir).some((f) => f.endsWith('.csproj'))) return 'dotnet';
+  } catch {
+    /* ignore */
+  }
+  return 'unknown';
+}
+
+function copyTemplate(lang: InitLanguage, targetDir: string): void {
+  const map: Record<InitLanguage, { src: string; dest: string } | null> = {
+    typescript: { src: 'typescript/ductape.example.ts', dest: 'ductape.example.ts' },
+    python: { src: 'python/ductape_example.py', dest: 'ductape_example.py' },
+    go: { src: 'go/main.go', dest: 'ductape_example.go' },
+    dotnet: { src: 'dotnet/Program.cs', dest: 'DuctapeExample.cs' },
+    unknown: null,
+  };
+  const entry = map[lang];
+  if (!entry) return;
+  const srcPath = path.join(TEMPLATES_ROOT, entry.src);
+  const destPath = path.join(targetDir, entry.dest);
+  if (!fs.existsSync(destPath) && fs.existsSync(srcPath)) {
+    fs.copyFileSync(srcPath, destPath);
+  }
+}
+
+export function writeInitArtifacts(dir: string, lang: InitLanguage): void {
+  const envContent = `# Ductape — credentials from Workbench → SDK Access
+DUCTAPE_ACCESS_KEY=
+# Passed to new Ductape({ accessKey, product, env }) — constructor is the only place for product/env defaults
+DUCTAPE_PRODUCT=
+DUCTAPE_ENV=dev
+`;
+
+  const envPath = path.join(dir, '.env.ductape.example');
+  if (!fs.existsSync(envPath)) fs.writeFileSync(envPath, envContent);
+
+  const ductapeDir = path.join(dir, '.ductape');
+  fs.mkdirSync(ductapeDir, { recursive: true });
+
+  const readme = `# Ductape project
+
+Linked via \`ductape link\`. Manage resources with:
+
+\`\`\`bash
+ductape resources storage list
+ductape resources databases create -f database.json
+\`\`\`
+
+Docs: https://docs.ductape.app/docs/cli/
+`;
+  const readmePath = path.join(ductapeDir, 'README.md');
+  if (!fs.existsSync(readmePath)) fs.writeFileSync(readmePath, readme);
+
+  copyTemplate(lang, dir);
+
+  const gitignorePath = path.join(dir, '.gitignore');
+  if (fs.existsSync(gitignorePath)) {
+    const gi = fs.readFileSync(gitignorePath, 'utf8');
+    if (!gi.includes('.env') && !gi.includes('.env.local')) {
+      fs.appendFileSync(gitignorePath, '\n.env\n.env.local\n');
+    }
+  }
+}

package/src/lib/workspace-context.ts

@@ -0,0 +1,43 @@
+import {
+  getActiveProfileName,
+  getActiveWorkspaceId,
+  getApiUrl,
+  loadCredentials,
+  type Credentials,
+} from './config.js';
+import { requireCredentials } from './proxy/context.js';
+
+export interface WorkspaceContext {
+  credentials: Credentials;
+  workspaceId: string;
+  apiUrl: string;
+  profile: string;
+}
+
+export function requireWorkspaceContext(opts?: { profile?: string }): WorkspaceContext {
+  const credentials = requireCredentials();
+  const workspaceId = getActiveWorkspaceId();
+  if (!workspaceId) {
+    throw new Error('No active workspace. Run: ductape login or ductape workspaces use');
+  }
+  const profile = opts?.profile ?? getActiveProfileName(null);
+  return {
+    credentials,
+    workspaceId,
+    apiUrl: getApiUrl(profile),
+    profile,
+  };
+}
+
+/** Query params required by integrations/apps REST endpoints (matches Workbench). */
+export function workspaceAuthQuery(
+  ctx: WorkspaceContext,
+  extra?: Record<string, string>,
+): Record<string, string> {
+  return {
+    user_id: ctx.credentials.user_id,
+    public_key: ctx.credentials.public_key,
+    workspace_id: ctx.workspaceId,
+    ...extra,
+  };
+}

package/src/lib/workspaces.ts

@@ -0,0 +1,283 @@
+import select from '@inquirer/select';
+import { ApiClient } from './api-client.js';
+import {
+  findProjectConfig,
+  getApiUrl,
+  loadCredentials,
+  loadGlobalConfig,
+  saveCredentials,
+  saveGlobalConfig,
+  saveProjectConfig,
+  type Credentials,
+} from './config.js';
+import { success } from './output.js';
+
+/** Workspace entry from login or workspaces API (field names vary). */
+export interface WorkspaceSummary {
+  workspace_id?: string;
+  workspace_name?: string;
+  _id?: string;
+  name?: string;
+  tag?: string;
+  default?: boolean;
+  accepted?: boolean;
+}
+
+export function workspaceId(w: WorkspaceSummary): string {
+  const id = w.workspace_id ?? w._id;
+  if (!id) throw new Error('Workspace entry missing id');
+  return id;
+}
+
+export function workspaceLabel(w: WorkspaceSummary): string {
+  return w.workspace_name ?? w.name ?? w.tag ?? workspaceId(w);
+}
+
+/** Human-readable workspace tag for .ductape/config.json (slug of name, or explicit tag). */
+export function workspaceTag(w: WorkspaceSummary): string {
+  if (w.tag?.trim()) return w.tag.trim();
+  return slugifyTag(workspaceLabel(w));
+}
+
+export function slugifyTag(value: string): string {
+  return value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+export function normalizeWorkspaces(raw: unknown[]): WorkspaceSummary[] {
+  return raw
+    .filter((w): w is Record<string, unknown> => Boolean(w) && typeof w === 'object')
+    .map((w) => ({
+      workspace_id: String(w.workspace_id ?? w._id ?? ''),
+      workspace_name: (w.workspace_name ?? w.name ?? w.tag) as string | undefined,
+      _id: w._id as string | undefined,
+      name: w.name as string | undefined,
+      tag: w.tag as string | undefined,
+      default: Boolean(w.default),
+      accepted: w.accepted as boolean | undefined,
+    }))
+    .filter((w) => w.workspace_id.length > 0);
+}
+
+export function getActiveWorkspace(): { id: string; name?: string; tag?: string } | null {
+  const global = loadGlobalConfig();
+  if (global.active_workspace_id) {
+    return {
+      id: global.active_workspace_id,
+      name: global.active_workspace_name,
+      tag: global.active_workspace_tag,
+    };
+  }
+  return null;
+}
+
+export function setActiveWorkspace(id: string, name?: string, tag?: string): void {
+  const global = loadGlobalConfig();
+  global.active_workspace_id = id;
+  global.active_workspace_name = name;
+  if (tag) global.active_workspace_tag = tag;
+  saveGlobalConfig(global);
+}
+
+export function clearActiveWorkspace(): void {
+  const global = loadGlobalConfig();
+  delete global.active_workspace_id;
+  delete global.active_workspace_name;
+  delete global.active_workspace_tag;
+  saveGlobalConfig(global);
+}
+
+export async function fetchWorkspaces(profile?: string): Promise<WorkspaceSummary[]> {
+  const creds = loadCredentials();
+  if (!creds) throw new Error('Not logged in. Run: ductape login');
+
+  const cached = normalizeWorkspaces(creds.workspaces ?? []);
+  const api = ApiClient.forProfile(profile, creds);
+  const apiUrl = getApiUrl(profile);
+
+  try {
+    const res = await fetch(
+      `${apiUrl}/workspaces/v1/fetch/${creds.user_id}?user_id=${encodeURIComponent(creds.user_id)}&public_key=${encodeURIComponent(creds.public_key)}`,
+      { headers: { Authorization: `Bearer ${creds.auth_token}` } },
+    );
+    const body = await res.json();
+    if (!res.ok) throw new Error(body.message ?? `Failed to list workspaces (${res.status})`);
+    const data = body.data ?? body;
+    const list = Array.isArray(data) ? data : (data?.result ?? data?.workspaces ?? []);
+    const normalized = normalizeWorkspaces(list as unknown[]);
+    if (normalized.length > 0) {
+      saveCredentials({ ...creds, workspaces: normalized as Credentials['workspaces'] });
+      return normalized;
+    }
+  } catch {
+    // fall through to cache / api client
+  }
+
+  try {
+    const list = await api.get<WorkspaceSummary[]>(
+      `/workspaces/v1/fetch/${creds.user_id}?user_id=${encodeURIComponent(creds.user_id)}&public_key=${encodeURIComponent(creds.public_key)}`,
+    );
+    const normalized = normalizeWorkspaces(list as unknown[]);
+    if (normalized.length > 0) {
+      saveCredentials({ ...creds, workspaces: normalized as Credentials['workspaces'] });
+      return normalized;
+    }
+  } catch {
+    // ignore
+  }
+
+  return cached;
+}
+
+export function findWorkspace(
+  workspaces: WorkspaceSummary[],
+  selector: string,
+): WorkspaceSummary | undefined {
+  const trimmed = selector.trim();
+  const idx = Number(trimmed);
+  if (!Number.isNaN(idx) && workspaces[idx]) return workspaces[idx];
+
+  return workspaces.find(
+    (w) =>
+      workspaceId(w) === trimmed ||
+      workspaceLabel(w).toLowerCase() === trimmed.toLowerCase() ||
+      w.tag?.toLowerCase() === trimmed.toLowerCase(),
+  );
+}
+
+export function printWorkspaceTable(
+  workspaces: WorkspaceSummary[],
+  activeId?: string | null,
+): void {
+  if (workspaces.length === 0) {
+    console.log('No workspaces found for this account.');
+    return;
+  }
+  workspaces.forEach((w, i) => {
+    const id = workspaceId(w);
+    const label = workspaceLabel(w);
+    const markers: string[] = [];
+    if (activeId && id === activeId) markers.push('active');
+    if (w.default) markers.push('default');
+    const suffix = markers.length ? ` (${markers.join(', ')})` : '';
+    console.log(`  [${i}] ${label}${suffix}`);
+    console.log(`      ${id}`);
+  });
+}
+
+export async function promptWorkspaceSelection(
+  workspaces: WorkspaceSummary[],
+  opts?: { message?: string },
+): Promise<WorkspaceSummary> {
+  if (workspaces.length === 0) {
+    throw new Error('No workspaces available. Create one in the Workbench first.');
+  }
+
+  if (workspaces.length === 1) {
+    const only = workspaces[0];
+    setActiveWorkspace(workspaceId(only), workspaceLabel(only), workspaceTag(only));
+    return only;
+  }
+
+  const active = getActiveWorkspace();
+  const activeId = active?.id ?? null;
+  const defaultWs =
+    workspaces.find((w) => active && workspaceId(w) === active.id) ??
+    workspaces.find((w) => w.default) ??
+    workspaces[0];
+  const defaultIdx = workspaces.indexOf(defaultWs);
+
+  // Non-interactive (CI, pipes): keep default without prompting.
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    return defaultWs;
+  }
+
+  const choiceIndex = await select<number>({
+    message: opts?.message ?? 'Select a workspace',
+    pageSize: Math.min(12, workspaces.length),
+    default: defaultIdx >= 0 ? defaultIdx : 0,
+    choices: workspaces.map((w, i) => {
+      const id = workspaceId(w);
+      const label = workspaceLabel(w);
+      const markers: string[] = [];
+      if (activeId && id === activeId) markers.push('active');
+      if (w.default) markers.push('default');
+      const suffix = markers.length ? ` · ${markers.join(', ')}` : '';
+      return {
+        name: label + suffix,
+        value: i,
+        description: id,
+      };
+    }),
+  });
+
+  return workspaces[choiceIndex];
+}
+
+export async function applyActiveWorkspace(
+  workspace: WorkspaceSummary,
+  opts?: { syncProject?: boolean; dir?: string },
+): Promise<void> {
+  const id = workspaceId(workspace);
+  const name = workspaceLabel(workspace);
+  const tag = workspaceTag(workspace);
+  setActiveWorkspace(id, name, tag);
+
+  if (opts?.syncProject !== false) {
+    const found = findProjectConfig(opts?.dir);
+    if (found) {
+      saveProjectConfig(found.dir, {
+        ...found.config,
+        workspace_tag: tag,
+        workspace_id: id,
+      });
+    }
+  }
+}
+
+export async function selectAndApplyWorkspace(opts?: {
+  profile?: string;
+  selector?: string;
+  skipPrompt?: boolean;
+  syncProject?: boolean;
+  dir?: string;
+}): Promise<WorkspaceSummary> {
+  const workspaces = await fetchWorkspaces(opts?.profile);
+
+  let chosen: WorkspaceSummary;
+  if (opts?.selector) {
+    const match = findWorkspace(workspaces, opts.selector);
+    if (!match) throw new Error(`Workspace not found: ${opts.selector}`);
+    chosen = match;
+  } else if (opts?.skipPrompt) {
+    const active = getActiveWorkspace();
+    const match = active ? findWorkspace(workspaces, active.id) : undefined;
+    chosen = match ?? workspaces.find((w) => w.default) ?? workspaces[0];
+    if (!chosen) throw new Error('No workspace to select');
+  } else {
+    chosen = await promptWorkspaceSelection(workspaces);
+  }
+
+  await applyActiveWorkspace(chosen, { syncProject: opts?.syncProject, dir: opts?.dir });
+  return chosen;
+}
+
+export async function finalizeLoginWorkspace(opts?: {
+  profile?: string;
+  workspace?: string;
+  skipPrompt?: boolean;
+}): Promise<void> {
+  const chosen = await selectAndApplyWorkspace({
+    profile: opts?.profile,
+    selector: opts?.workspace,
+    skipPrompt: opts?.skipPrompt,
+    syncProject: true,
+  });
+  const workspaces = await fetchWorkspaces(opts?.profile);
+  const hint =
+    workspaces.length > 1 ? '\nSwitch anytime: ductape workspaces use' : '';
+  success(`Active workspace: ${workspaceLabel(chosen)} (${workspaceId(chosen)})${hint}`);
+}

package/templates/dotnet/Program.cs

@@ -0,0 +1,2 @@
+// dotnet add package Ductape.Sdk
+Console.WriteLine("Ductape client ready");

package/templates/go/main.go

@@ -0,0 +1,8 @@
+package main
+
+import "fmt"
+
+// go get github.com/ductape/ductape/sdk/go
+func main() {
+	fmt.Println("Ductape client ready")
+}

package/templates/python/ductape_example.py

@@ -0,0 +1,16 @@
+"""Ductape client example."""
+import os
+
+# from ductape import Ductape
+#
+# client = Ductape(
+#     publishable_key=os.environ["DUCTAPE_PUBLISHABLE_KEY"],
+#     product=os.environ["DUCTAPE_PRODUCT"],
+#     env=os.environ.get("DUCTAPE_ENV", "dev"),
+# )
+
+def main():
+    print("Ductape client ready")
+
+if __name__ == "__main__":
+    main()

package/templates/typescript/ductape.example.ts

@@ -0,0 +1,18 @@
+/**
+ * Ductape SDK example — product/env defaults are set on the constructor only.
+ * CLI: `ductape login` + `ductape link` (see .ductape/config.json).
+ */
+import Ductape from '@ductape/sdk';
+
+const ductape = new Ductape({
+  accessKey: process.env.DUCTAPE_ACCESS_KEY!,
+  product: process.env.DUCTAPE_PRODUCT!,
+  env: process.env.DUCTAPE_ENV ?? 'dev',
+});
+
+async function main() {
+  // await ductape.databases.connect({ database: 'main-db' });
+  console.log('Ductape client ready');
+}
+
+main().catch(console.error);

package/test/encryption.test.ts

@@ -0,0 +1,20 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import CryptoJS from 'crypto-js';
+import { encryptProxyPayload } from '../src/lib/encryption.js';
+
+describe('encryptProxyPayload', () => {
+  it('produces iv:ciphertext format compatible with backend', () => {
+    const publicKey = 'test-public-key-12345';
+    const data = { module: 'storage', method: 'list', params: ['my-product'], user_id: 'u1' };
+    const encrypted = encryptProxyPayload(data, publicKey);
+    assert.match(encrypted, /^[0-9a-f]+:/i);
+
+    const [ivHex, cipherText] = encrypted.split(':');
+    const iv = CryptoJS.enc.Hex.parse(ivHex);
+    const hashedKey = CryptoJS.SHA256(publicKey);
+    const decrypted = CryptoJS.AES.decrypt(cipherText, hashedKey, { iv });
+    const json = JSON.parse(decrypted.toString(CryptoJS.enc.Utf8));
+    assert.deepEqual(json, data);
+  });
+});

package/test/forms.test.ts

@@ -0,0 +1,25 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { getFormSchema, schemaKeyForEntity, schemaKeyForResource } from '../src/lib/forms/schemas.js';
+
+describe('forms schemas', () => {
+  it('resolves product and component keys', () => {
+    assert.equal(schemaKeyForEntity('products', 'create'), 'products:create');
+    assert.equal(schemaKeyForResource('storage', 'create'), 'storage:create');
+    assert.equal(schemaKeyForResource('databases', 'connect'), 'databases:connect');
+  });
+
+  it('storage create includes enum type in envs', () => {
+    const schema = getFormSchema('storage:create');
+    assert.ok(schema);
+    const envs = schema!.fields.find((f) => f.kind === 'envs');
+    assert.equal(envs?.envsVariant, 'storage');
+  });
+
+  it('databases create has database type enum', () => {
+    const schema = getFormSchema('databases:create');
+    const typeField = schema!.fields.find((f) => f.key === 'type');
+    assert.equal(typeField?.kind, 'enum');
+    assert.ok(typeField?.choices?.includes('postgresql'));
+  });
+});

package/test/platform-api.test.ts

@@ -0,0 +1,19 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+
+// Test unwrap helpers indirectly via exported patterns — use small inline copies for unit scope
+function unwrapList<T>(result: unknown): T[] {
+  if (Array.isArray(result)) return result;
+  if (result && typeof result === 'object' && Array.isArray((result as { data?: T[] }).data)) {
+    return (result as { data: T[] }).data;
+  }
+  return [];
+}
+
+describe('platform-api helpers', () => {
+  it('unwraps array responses', () => {
+    assert.deepEqual(unwrapList([{ tag: 'a' }]), [{ tag: 'a' }]);
+    assert.deepEqual(unwrapList({ data: [{ tag: 'b' }] }), [{ tag: 'b' }]);
+    assert.deepEqual(unwrapList({}), []);
+  });
+});