@alvera-ai/platform-sdk 0.5.2 → 0.6.0

package/src/config.ts

@@ -0,0 +1,205 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import {
+  DEFAULT_ENVIRONMENT,
+  ENVIRONMENTS,
+  type EnvironmentName,
+} from './environments.generated.js';
+
+export { ENVIRONMENTS, DEFAULT_ENVIRONMENT, type EnvironmentName } from './environments.generated.js';
+
+const CONFIG_DIR = join(homedir(), '.alvera-ai');
+const CONFIG_FILE = join(CONFIG_DIR, 'config');
+const CREDS_FILE = join(CONFIG_DIR, 'credentials');
+
+export interface ProfileConfig {
+  environment?: string;
+  base_url?: string;
+  tenant_slug?: string;
+  email?: string;
+}
+
+export interface ProfileCreds {
+  session_token?: string;
+  expires_at?: string;
+}
+
+export interface ResolvedProfile {
+  profile: string;
+  environment: EnvironmentName;
+  baseUrl: string;
+  tenantSlug: string | null;
+  email: string | null;
+  sessionToken: string | null;
+  expiresAt: string | null;
+}
+
+function isEnvironmentName(name: string): name is EnvironmentName {
+  return Object.prototype.hasOwnProperty.call(ENVIRONMENTS, name);
+}
+
+function resolveEnvironment(cfg: ProfileConfig): EnvironmentName {
+  const candidate = process.env.ALVERA_ENV ?? cfg.environment ?? DEFAULT_ENVIRONMENT;
+  if (!isEnvironmentName(candidate)) {
+    const valid = Object.keys(ENVIRONMENTS).join(', ');
+    throw new Error(
+      `Unknown environment "${candidate}". Valid environments: ${valid}.`,
+    );
+  }
+  return candidate;
+}
+
+// ---------------------------------------------------------------------------
+// Minimal INI parser / serializer. Handles [section] headers and key=value
+// lines; ignores comments (# or ;) and blank lines.
+// ---------------------------------------------------------------------------
+
+type IniSections = Record<string, Record<string, string>>;
+
+function parseIni(text: string): IniSections {
+  const sections: IniSections = {};
+  let current = 'default';
+  sections[current] = {};
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#') || line.startsWith(';')) continue;
+    const header = line.match(/^\[(.+)\]$/);
+    if (header) {
+      current = header[1]!.trim();
+      sections[current] ??= {};
+      continue;
+    }
+    const eq = line.indexOf('=');
+    if (eq === -1) continue;
+    const key = line.slice(0, eq).trim();
+    const value = line.slice(eq + 1).trim();
+    sections[current]![key] = value;
+  }
+  return sections;
+}
+
+function serializeIni(sections: IniSections): string {
+  const parts: string[] = [];
+  const names = Object.keys(sections).sort((a, b) =>
+    a === 'default' ? -1 : b === 'default' ? 1 : a.localeCompare(b),
+  );
+  for (const name of names) {
+    const body = sections[name]!;
+    if (Object.keys(body).length === 0) continue;
+    parts.push(`[${name}]`);
+    for (const [k, v] of Object.entries(body)) {
+      parts.push(`${k} = ${v}`);
+    }
+    parts.push('');
+  }
+  return parts.join('\n');
+}
+
+function readIni(path: string): IniSections {
+  if (!existsSync(path)) return {};
+  return parseIni(readFileSync(path, 'utf8'));
+}
+
+function writeIni(path: string, sections: IniSections, mode: number): void {
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  writeFileSync(path, serializeIni(sections), { mode });
+  chmodSync(path, mode);
+}
+
+// ---------------------------------------------------------------------------
+// Profile key helpers. AWS convention: [default] and [profile <name>] in
+// config; [default] and [<name>] in credentials.
+// ---------------------------------------------------------------------------
+
+function configKey(profile: string): string {
+  return profile === 'default' ? 'default' : `profile ${profile}`;
+}
+
+function credsKey(profile: string): string {
+  return profile;
+}
+
+export function getProfileName(flag?: string): string {
+  return flag ?? process.env.ALVERA_PROFILE ?? 'default';
+}
+
+// ---------------------------------------------------------------------------
+// Read / write
+// ---------------------------------------------------------------------------
+
+export function readProfileConfig(profile: string): ProfileConfig {
+  const sections = readIni(CONFIG_FILE);
+  return (sections[configKey(profile)] ?? {}) as ProfileConfig;
+}
+
+export function readProfileCreds(profile: string): ProfileCreds {
+  const sections = readIni(CREDS_FILE);
+  return (sections[credsKey(profile)] ?? {}) as ProfileCreds;
+}
+
+export function writeProfileConfig(
+  profile: string,
+  patch: ProfileConfig,
+  unset: ReadonlyArray<keyof ProfileConfig> = [],
+): void {
+  const sections = readIni(CONFIG_FILE);
+  const key = configKey(profile);
+  const merged = { ...(sections[key] ?? {}), ...stripUndefined(patch as Record<string, unknown>) };
+  for (const k of unset) delete merged[k as string];
+  sections[key] = merged;
+  writeIni(CONFIG_FILE, sections, 0o600);
+}
+
+export function writeProfileCreds(profile: string, patch: ProfileCreds): void {
+  const sections = readIni(CREDS_FILE);
+  const key = credsKey(profile);
+  sections[key] = { ...(sections[key] ?? {}), ...stripUndefined(patch as Record<string, unknown>) };
+  writeIni(CREDS_FILE, sections, 0o600);
+}
+
+export function clearProfileCreds(profile: string): void {
+  const sections = readIni(CREDS_FILE);
+  delete sections[credsKey(profile)];
+  writeIni(CREDS_FILE, sections, 0o600);
+}
+
+function stripUndefined(obj: Record<string, unknown>): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v === undefined || v === null || v === '') continue;
+    out[k] = String(v);
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// Resolve a profile: merge config + creds + env var overrides. Env vars take
+// precedence (so scripts/CI can override without touching files).
+// ---------------------------------------------------------------------------
+
+export function resolveProfile(profile: string): ResolvedProfile {
+  const cfg = readProfileConfig(profile);
+  const creds = readProfileCreds(profile);
+  const environment = resolveEnvironment(cfg);
+  return {
+    profile,
+    environment,
+    baseUrl:
+      process.env.ALVERA_BASE_URL ??
+      cfg.base_url ??
+      ENVIRONMENTS[environment].base_url,
+    tenantSlug:
+      process.env.ALVERA_TENANT ?? cfg.tenant_slug ?? null,
+    email: process.env.ALVERA_EMAIL ?? cfg.email ?? null,
+    sessionToken:
+      process.env.ALVERA_SESSION_TOKEN ?? creds.session_token ?? null,
+    expiresAt: creds.expires_at ?? null,
+  };
+}
+
+export const CONFIG_PATHS = {
+  dir: CONFIG_DIR,
+  config: CONFIG_FILE,
+  credentials: CREDS_FILE,
+};

package/src/environments.generated.ts

@@ -0,0 +1,16 @@
+// Generated from spec/openapi.yaml by scripts/gen-environments.ts — do not edit.
+
+export interface EnvironmentConfig {
+  readonly base_url: string;
+  readonly description: string;
+}
+
+export const ENVIRONMENTS = {
+  local: { base_url: "http://localhost:4000", description: "Development server" },
+  demo: { base_url: "https://platform-hh.alvera.ai", description: "Himangshu Demo server" },
+  prod: { base_url: "https://app.alvera.ai", description: "Prod Server" },
+} as const satisfies Readonly<Record<string, EnvironmentConfig>>;
+
+export const DEFAULT_ENVIRONMENT = "prod" as const;
+
+export type EnvironmentName = keyof typeof ENVIRONMENTS;

package/src/generated/client/client.gen.ts

@@ -0,0 +1,298 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import { createSseClient } from '../core/serverSentEvents.gen';
+import type { HttpMethod } from '../core/types.gen';
+import { getValidRequestBody } from '../core/utils.gen';
+import type { Client, Config, RequestOptions, ResolvedRequestOptions } from './types.gen';
+import {
+  buildUrl,
+  createConfig,
+  createInterceptors,
+  getParseAs,
+  mergeConfigs,
+  mergeHeaders,
+  setAuthParams,
+} from './utils.gen';
+
+type ReqInit = Omit<RequestInit, 'body' | 'headers'> & {
+  body?: any;
+  headers: ReturnType<typeof mergeHeaders>;
+};
+
+export const createClient = (config: Config = {}): Client => {
+  let _config = mergeConfigs(createConfig(), config);
+
+  const getConfig = (): Config => ({ ..._config });
+
+  const setConfig = (config: Config): Config => {
+    _config = mergeConfigs(_config, config);
+    return getConfig();
+  };
+
+  const interceptors = createInterceptors<Request, Response, unknown, ResolvedRequestOptions>();
+
+  const beforeRequest = async <
+    TData = unknown,
+    TResponseStyle extends 'data' | 'fields' = 'fields',
+    ThrowOnError extends boolean = boolean,
+    Url extends string = string,
+  >(
+    options: RequestOptions<TData, TResponseStyle, ThrowOnError, Url>,
+  ) => {
+    const opts = {
+      ..._config,
+      ...options,
+      fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+      headers: mergeHeaders(_config.headers, options.headers),
+      serializedBody: undefined as string | undefined,
+    };
+
+    if (opts.security) {
+      await setAuthParams({
+        ...opts,
+        security: opts.security,
+      });
+    }
+
+    if (opts.requestValidator) {
+      await opts.requestValidator(opts);
+    }
+
+    if (opts.body !== undefined && opts.bodySerializer) {
+      opts.serializedBody = opts.bodySerializer(opts.body) as string | undefined;
+    }
+
+    // remove Content-Type header if body is empty to avoid sending invalid requests
+    if (opts.body === undefined || opts.serializedBody === '') {
+      opts.headers.delete('Content-Type');
+    }
+
+    const resolvedOpts = opts as typeof opts &
+      ResolvedRequestOptions<TResponseStyle, ThrowOnError, Url>;
+    const url = buildUrl(resolvedOpts);
+
+    return { opts: resolvedOpts, url };
+  };
+
+  const request: Client['request'] = async (options) => {
+    const { opts, url } = await beforeRequest(options);
+    const requestInit: ReqInit = {
+      redirect: 'follow',
+      ...opts,
+      body: getValidRequestBody(opts),
+    };
+
+    let request = new Request(url, requestInit);
+
+    for (const fn of interceptors.request.fns) {
+      if (fn) {
+        request = await fn(request, opts);
+      }
+    }
+
+    // fetch must be assigned here, otherwise it would throw the error:
+    // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
+    const _fetch = opts.fetch!;
+    let response: Response;
+
+    try {
+      response = await _fetch(request);
+    } catch (error) {
+      // Handle fetch exceptions (AbortError, network errors, etc.)
+      let finalError = error;
+
+      for (const fn of interceptors.error.fns) {
+        if (fn) {
+          finalError = (await fn(error, undefined as any, request, opts)) as unknown;
+        }
+      }
+
+      finalError = finalError || ({} as unknown);
+
+      if (opts.throwOnError) {
+        throw finalError;
+      }
+
+      // Return error response
+      return opts.responseStyle === 'data'
+        ? undefined
+        : {
+            error: finalError,
+            request,
+            response: undefined as any,
+          };
+    }
+
+    for (const fn of interceptors.response.fns) {
+      if (fn) {
+        response = await fn(response, request, opts);
+      }
+    }
+
+    const result = {
+      request,
+      response,
+    };
+
+    if (response.ok) {
+      const parseAs =
+        (opts.parseAs === 'auto'
+          ? getParseAs(response.headers.get('Content-Type'))
+          : opts.parseAs) ?? 'json';
+
+      if (response.status === 204 || response.headers.get('Content-Length') === '0') {
+        let emptyData: any;
+        switch (parseAs) {
+          case 'arrayBuffer':
+          case 'blob':
+          case 'text':
+            emptyData = await response[parseAs]();
+            break;
+          case 'formData':
+            emptyData = new FormData();
+            break;
+          case 'stream':
+            emptyData = response.body;
+            break;
+          case 'json':
+          default:
+            emptyData = {};
+            break;
+        }
+        return opts.responseStyle === 'data'
+          ? emptyData
+          : {
+              data: emptyData,
+              ...result,
+            };
+      }
+
+      let data: any;
+      switch (parseAs) {
+        case 'arrayBuffer':
+        case 'blob':
+        case 'formData':
+        case 'text':
+          data = await response[parseAs]();
+          break;
+        case 'json': {
+          // Some servers return 200 with no Content-Length and empty body.
+          // response.json() would throw; read as text and parse if non-empty.
+          const text = await response.text();
+          data = text ? JSON.parse(text) : {};
+          break;
+        }
+        case 'stream':
+          return opts.responseStyle === 'data'
+            ? response.body
+            : {
+                data: response.body,
+                ...result,
+              };
+      }
+
+      if (parseAs === 'json') {
+        if (opts.responseValidator) {
+          await opts.responseValidator(data);
+        }
+
+        if (opts.responseTransformer) {
+          data = await opts.responseTransformer(data);
+        }
+      }
+
+      return opts.responseStyle === 'data'
+        ? data
+        : {
+            data,
+            ...result,
+          };
+    }
+
+    const textError = await response.text();
+    let jsonError: unknown;
+
+    try {
+      jsonError = JSON.parse(textError);
+    } catch {
+      // noop
+    }
+
+    const error = jsonError ?? textError;
+    let finalError = error;
+
+    for (const fn of interceptors.error.fns) {
+      if (fn) {
+        finalError = (await fn(error, response, request, opts)) as string;
+      }
+    }
+
+    finalError = finalError || ({} as string);
+
+    if (opts.throwOnError) {
+      throw finalError;
+    }
+
+    // TODO: we probably want to return error and improve types
+    return opts.responseStyle === 'data'
+      ? undefined
+      : {
+          error: finalError,
+          ...result,
+        };
+  };
+
+  const makeMethodFn = (method: Uppercase<HttpMethod>) => (options: RequestOptions) =>
+    request({ ...options, method });
+
+  const makeSseFn = (method: Uppercase<HttpMethod>) => async (options: RequestOptions) => {
+    const { opts, url } = await beforeRequest(options);
+    return createSseClient({
+      ...opts,
+      body: opts.body as BodyInit | null | undefined,
+      headers: opts.headers as unknown as Record<string, string>,
+      method,
+      onRequest: async (url, init) => {
+        let request = new Request(url, init);
+        for (const fn of interceptors.request.fns) {
+          if (fn) {
+            request = await fn(request, opts);
+          }
+        }
+        return request;
+      },
+      serializedBody: getValidRequestBody(opts) as BodyInit | null | undefined,
+      url,
+    });
+  };
+
+  const _buildUrl: Client['buildUrl'] = (options) => buildUrl({ ..._config, ...options });
+
+  return {
+    buildUrl: _buildUrl,
+    connect: makeMethodFn('CONNECT'),
+    delete: makeMethodFn('DELETE'),
+    get: makeMethodFn('GET'),
+    getConfig,
+    head: makeMethodFn('HEAD'),
+    interceptors,
+    options: makeMethodFn('OPTIONS'),
+    patch: makeMethodFn('PATCH'),
+    post: makeMethodFn('POST'),
+    put: makeMethodFn('PUT'),
+    request,
+    setConfig,
+    sse: {
+      connect: makeSseFn('CONNECT'),
+      delete: makeSseFn('DELETE'),
+      get: makeSseFn('GET'),
+      head: makeSseFn('HEAD'),
+      options: makeSseFn('OPTIONS'),
+      patch: makeSseFn('PATCH'),
+      post: makeSseFn('POST'),
+      put: makeSseFn('PUT'),
+      trace: makeSseFn('TRACE'),
+    },
+    trace: makeMethodFn('TRACE'),
+  } as Client;
+};

package/src/generated/client/index.ts

@@ -0,0 +1,25 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+export type { Auth } from '../core/auth.gen';
+export type { QuerySerializerOptions } from '../core/bodySerializer.gen';
+export {
+  formDataBodySerializer,
+  jsonBodySerializer,
+  urlSearchParamsBodySerializer,
+} from '../core/bodySerializer.gen';
+export { buildClientParams } from '../core/params.gen';
+export { serializeQueryKeyValue } from '../core/queryKeySerializer.gen';
+export { createClient } from './client.gen';
+export type {
+  Client,
+  ClientOptions,
+  Config,
+  CreateClientConfig,
+  Options,
+  RequestOptions,
+  RequestResult,
+  ResolvedRequestOptions,
+  ResponseStyle,
+  TDataShape,
+} from './types.gen';
+export { createConfig, mergeHeaders } from './utils.gen';