@alvera-ai/platform-sdk 0.9.0 → 0.10.0-rc.2

package/src/cli/helpers.ts

@@ -1,128 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { createInterface } from 'node:readline';
-import { Command } from 'commander';
-import { ValiError } from 'valibot';
-import { createUnvalidatedPlatformApi } from '../client.js';
-import { getProfileName, resolveProfile } from '../config.js';
-
-export interface GlobalOpts {
-  profile?: string;
-  env?: string;
-}
-
-export function out(value: unknown): void {
-  process.stdout.write(JSON.stringify(value, null, 2) + '\n');
-}
-
-export function die(message: string, code = 1): never {
-  process.stderr.write(`alvera: ${message}\n`);
-  process.exit(code);
-}
-
-export async function prompt(question: string, { hidden = false } = {}): Promise<string> {
-  const rl = createInterface({ input: process.stdin, output: process.stderr, terminal: true });
-  if (!hidden) {
-    return new Promise((resolve) => rl.question(question, (ans) => {
-      rl.close();
-      resolve(ans);
-    }));
-  }
-  const anyRl = rl as unknown as { _writeToOutput: (s: string) => void };
-  const originalWrite = anyRl._writeToOutput.bind(rl);
-  anyRl._writeToOutput = (s: string) => {
-    if (s.includes(question)) originalWrite(s);
-    else originalWrite('');
-  };
-  return new Promise((resolve) => rl.question(question, (ans) => {
-    rl.close();
-    process.stderr.write('\n');
-    resolve(ans);
-  }));
-}
-
-export function readBody(body: string | undefined, bodyFile: string | undefined): Record<string, unknown> {
-  if (body && bodyFile) die('use only one of --body or --body-file');
-  let raw: string;
-  if (body) raw = body;
-  else if (bodyFile === '-') raw = readFileSync(0, 'utf8');
-  else if (bodyFile) raw = readFileSync(bodyFile, 'utf8');
-  else die('missing request body (pass --body <json> or --body-file <path>)');
-  try {
-    const parsed = JSON.parse(raw);
-    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
-      die('body must be a JSON object');
-    }
-    return parsed;
-  } catch (err) {
-    die(`invalid JSON in body: ${(err as Error).message}`);
-  }
-}
-
-export function resolveTenant(explicit: string | undefined, profileTenant: string | null): string {
-  const tenant = explicit ?? profileTenant;
-  if (!tenant) die('tenant slug required (pass as argument or set `tenant_slug` in the profile)');
-  return tenant;
-}
-
-export function authedApi(opts: GlobalOpts) {
-  const profile = getProfileName(opts.profile);
-  const resolved = resolveProfile(profile);
-
-  if (resolved.apiKey) {
-    return {
-      api: createUnvalidatedPlatformApi({ baseUrl: resolved.baseUrl, apiKey: resolved.apiKey }),
-      resolved,
-    };
-  }
-
-  if (!resolved.sessionToken) {
-    die(
-      `no credentials for profile "${profile}". ` +
-        `Run \`alvera login --profile ${profile}\`, set ALVERA_SESSION_TOKEN, or set ALVERA_API_KEY.`,
-    );
-  }
-  if (resolved.expiresAt && new Date(resolved.expiresAt) < new Date()) {
-    die(
-      `session for profile "${profile}" expired at ${resolved.expiresAt}. ` +
-        `Run \`alvera login --profile ${profile}\` to refresh.`,
-    );
-  }
-  return {
-    api: createUnvalidatedPlatformApi({ baseUrl: resolved.baseUrl, sessionToken: resolved.sessionToken }),
-    resolved,
-  };
-}
-
-export async function run(fn: () => Promise<unknown>): Promise<void> {
-  try {
-    const result = await fn();
-    if (result !== undefined) out(result);
-  } catch (err) {
-    die(formatError(err));
-  }
-}
-
-export function formatError(err: unknown): string {
-  if (err instanceof ValiError) {
-    const lines = err.issues.map((issue) => {
-      const path = (issue.path ?? [])
-        .map((p: { key?: unknown }) => String(p.key ?? '?'))
-        .join('.') || '(root)';
-      return `  ${path}: ${issue.message}`;
-    });
-    return `validation failed:\n${lines.join('\n')}`;
-  }
-  if (err instanceof Error) return err.message;
-  if (err && typeof err === 'object') {
-    const detail = (err as { errors?: { detail?: unknown } }).errors?.detail;
-    if (typeof detail === 'string') return detail;
-    return JSON.stringify(err, null, 2);
-  }
-  return String(err);
-}
-
-export function bodyOption(cmd: Command): Command {
-  return cmd
-    .option('--body <json>', 'request body as a JSON string')
-    .option('--body-file <path>', 'path to a JSON file (or "-" for stdin)');
-}

package/src/cli/init.ts

@@ -1,123 +0,0 @@
-import { readFileSync, writeFileSync } from 'node:fs';
-import { createInterface } from 'node:readline';
-import { resolve } from 'node:path';
-import { Command } from 'commander';
-
-interface InitField {
-  key: string;
-  label: string;
-  default?: string;
-}
-type InitSection = { header: string; fields: InitField[] }
-
-const DB_KEYS = ['HOST', 'PORT', 'NAME', 'SCHEMA', 'AUTH_METHOD', 'USER', 'PASS', 'ENABLE_SSL'] as const;
-const DB_LABELS = ['host', 'port', 'database name', 'schema', 'auth method', 'user', 'password', 'enable SSL'] as const;
-const DB_DEFAULTS: Record<string, string> = { PORT: '5432', SCHEMA: 'public', AUTH_METHOD: 'password', ENABLE_SSL: 'false' };
-
-function dbSection(label: string, prefix: string): InitSection {
-  return {
-    header: label,
-    fields: DB_KEYS.map((k, i) => ({
-      key: `${prefix}_${k}`,
-      label: `${label} — ${DB_LABELS[i]}`,
-      default: DB_DEFAULTS[k],
-    })),
-  };
-}
-
-const STORAGE_KEYS = ['TYPE', 'REGION', 'ACCESS_KEY_ID', 'SECRET_ACCESS_KEY', 'ENDPOINT', 'BUCKET'] as const;
-const STORAGE_LABELS = ['type (aws/r2)', 'region', 'access key ID', 'secret access key', 'endpoint', 'bucket'] as const;
-
-function storageSection(label: string, prefix: string): InitSection {
-  return {
-    header: label,
-    fields: STORAGE_KEYS.map((k, i) => ({
-      key: `${prefix}_${k}`,
-      label: `${label} — ${STORAGE_LABELS[i]}`,
-      default: k === 'TYPE' ? 'aws' : undefined,
-    })),
-  };
-}
-
-async function collectAndWrite(sections: InitSection[], outPath: string): Promise<void> {
-  const allFields = sections.flatMap((s) => s.fields);
-
-  let answers: string[];
-  if (process.stdin.isTTY) {
-    const rl = createInterface({ input: process.stdin, output: process.stderr, terminal: true });
-    const ask = (q: string): Promise<string> =>
-      new Promise((res) => rl.question(q, (ans) => res(ans)));
-    answers = [];
-    for (const field of allFields) {
-      const dflt = field.default ?? '';
-      const suffix = dflt ? ` [${dflt}]` : '';
-      answers.push(await ask(`${field.label}${suffix}: `));
-    }
-    rl.close();
-  } else {
-    const raw = readFileSync(0, 'utf8');
-    answers = raw.split('\n');
-  }
-
-  const lines: string[] = [];
-  let idx = 0;
-  for (const section of sections) {
-    if (lines.length > 0) lines.push('');
-    lines.push(`# ${section.header}`);
-    for (const field of section.fields) {
-      const dflt = field.default ?? '';
-      const answer = (answers[idx++] ?? '').trim();
-      lines.push(`${field.key}=${answer || dflt}`);
-    }
-  }
-
-  const abs = resolve(process.cwd(), outPath);
-  writeFileSync(abs, lines.join('\n') + '\n');
-  process.stderr.write(`Wrote ${abs}\n`);
-}
-
-export function register(program: Command): void {
-  const initCmd = program.command('init').description('Generate a .env configuration file');
-
-  initCmd
-    .command('connected-app')
-    .description('Generate .env for SDK / connected-app integration')
-    .option('-o, --output <path>', 'output file path', '.env')
-    .action(async (opts: { output: string }) => {
-      await collectAndWrite([
-        {
-          header: 'Alvera connected-app configuration',
-          fields: [
-            { key: 'ALVERA_BASE_URL', label: 'Base URL', default: 'https://api.alvera.ai' },
-            { key: 'ALVERA_TENANT', label: 'Tenant slug' },
-            { key: 'ALVERA_DATALAKE', label: 'Datalake slug' },
-            { key: 'ALVERA_CONNECTED_APP', label: 'Connected app slug' },
-          ],
-        },
-      ], opts.output);
-    });
-
-  initCmd
-    .command('infra-setup')
-    .description('Generate .env for datalake infrastructure (databases + object storage)')
-    .option('-o, --output <path>', 'output file path', '.env')
-    .action(async (opts: { output: string }) => {
-      await collectAndWrite([
-        {
-          header: 'Datalake',
-          fields: [
-            { key: 'ALVERA_DATALAKE_NAME', label: 'Datalake name' },
-            { key: 'ALVERA_DATALAKE_DATA_DOMAIN', label: 'Data domain' },
-            { key: 'ALVERA_DATALAKE_TIMEZONE', label: 'Timezone', default: 'UTC' },
-            { key: 'ALVERA_DATALAKE_POOL_SIZE', label: 'Pool size', default: '10' },
-          ],
-        },
-        dbSection('Database — Unregulated Reader', 'ALVERA_DB_UNREG_READER'),
-        dbSection('Database — Unregulated Writer', 'ALVERA_DB_UNREG_WRITER'),
-        dbSection('Database — Regulated Reader', 'ALVERA_DB_REG_READER'),
-        dbSection('Database — Regulated Writer', 'ALVERA_DB_REG_WRITER'),
-        storageSection('Storage — Unregulated', 'ALVERA_STORAGE_UNREG'),
-        storageSection('Storage — Regulated', 'ALVERA_STORAGE_REG'),
-      ], opts.output);
-    });
-}

package/src/cli/raw.ts

@@ -1,65 +0,0 @@
-import { Command } from 'commander';
-import { getProfileName, resolveProfile } from '../config.js';
-import { type GlobalOpts, bodyOption, die, out, readBody } from './helpers.js';
-
-const ALLOWED_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'] as const;
-
-export function register(program: Command): void {
-  bodyOption(
-    program
-      .command('raw <method> <path>')
-      .description('Send an authenticated HTTP request bypassing SDK validation')
-      .option('--no-parse', 'print raw response text instead of pretty-printing JSON'),
-  )
-    .action(
-      async (
-        method: string,
-        path: string,
-        opts: { body?: string; bodyFile?: string; parse?: boolean },
-      ) => {
-        const upper = method.toUpperCase();
-        if (!ALLOWED_METHODS.includes(upper as (typeof ALLOWED_METHODS)[number])) {
-          die(`invalid method "${method}". Allowed: ${ALLOWED_METHODS.join(', ')}`);
-        }
-
-        const globalOpts = program.opts<GlobalOpts>();
-        const profile = getProfileName(globalOpts.profile);
-        const resolved = resolveProfile(profile);
-        if (!resolved.sessionToken && !resolved.apiKey) {
-          die(
-            `no credentials for profile "${profile}". ` +
-              `Run \`alvera login\`, set ALVERA_SESSION_TOKEN, or set ALVERA_API_KEY.`,
-          );
-        }
-
-        const url = `${resolved.baseUrl}${path.startsWith('/') ? path : `/${path}`}`;
-        const headers: Record<string, string> = resolved.apiKey
-          ? { 'X-API-Key': resolved.apiKey }
-          : { Authorization: `Bearer ${resolved.sessionToken!}` };
-
-        let fetchBody: string | undefined;
-        if (opts.body || opts.bodyFile) {
-          const parsed = readBody(opts.body, opts.bodyFile);
-          fetchBody = JSON.stringify(parsed);
-          headers['Content-Type'] = 'application/json';
-        }
-
-        const resp = await fetch(url, { method: upper, headers, body: fetchBody });
-        const text = await resp.text();
-
-        if (!resp.ok) {
-          die(`${upper} ${path} → ${resp.status} ${resp.statusText}: ${text}`);
-        }
-
-        if (opts.parse === false) {
-          process.stdout.write(text + '\n');
-        } else {
-          try {
-            out(JSON.parse(text));
-          } catch {
-            process.stdout.write(text + '\n');
-          }
-        }
-      },
-    );
-}