@fluxomni/api-client 0.11.0

package/dist/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Fluxomni TypeScript GraphQL API Client
+ *
+ * A thin Fluxomni GraphQL transport with:
+ * - Session-aware HTTP and WebSocket setup
+ * - Direct raw GraphQL execution for automation scripts
+ * - Generated GraphQL documents and types for typed callers
+ * - Browser and server convenience helpers without a hand-written domain SDK
+ *
+ * @example
+ * ```typescript
+ * import { GraphQLClient, StateDocument } from '@fluxomni/api-client';
+ *
+ * // Create client
+ * const client = new GraphQLClient({
+ *   httpEndpoint: 'http://localhost:8001/api',
+ *   wsEndpoint: 'ws://localhost:8001/api/subscriptions',
+ * });
+ *
+ * const data = await client.executeRaw<{
+ *   routes: { allRoutes: Array<{ id: string; label?: string | null }> };
+ * }>(`
+ *   query Routes {
+ *     routes { allRoutes { id label } }
+ *   }
+ * `);
+ *
+ * // Subscribe to state changes
+ * client.subscribe({ query: StateDocument }).subscribe({
+ *   next: (result) => {
+ *     console.log('Routes updated:', result.data);
+ *   },
+ *   error: (err) => console.error(err),
+ * });
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { type AuthRole, type AuthStatus, type AuthUser, createSessionFetch, type LoginOptions, type LoginResult, login, SESSION_COOKIE_NAME, } from './auth.js';
+export { type ConnectionCallbacks, GraphQLClient, type GraphQLClientConfig, type GraphQLClientLoginOptions, type GraphQLClientLoginResult, } from './client.js';
+export { classifyGraphQLError, ClientError, extractField, GraphQLError, type GraphQLErrorCategory, type GraphQLServerError, MissingDataError, MissingFieldError, NetworkError, } from './errors.js';
+export * from './generated/graphql.js';
+export type { DateTime } from './scalars.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAGH,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,UAAU,EACf,KAAK,QAAQ,EACb,kBAAkB,EAClB,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,EACL,mBAAmB,GACpB,MAAM,WAAW,CAAC;AACnB,OAAO,EACL,KAAK,mBAAmB,EACxB,aAAa,EACb,KAAK,mBAAmB,EACxB,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,GAC9B,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,oBAAoB,EACpB,WAAW,EACX,YAAY,EACZ,YAAY,EACZ,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACvB,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,GACb,MAAM,aAAa,CAAC;AAErB,cAAc,wBAAwB,CAAC;AACvC,YAAY,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,46 @@
+/**
+ * Fluxomni TypeScript GraphQL API Client
+ *
+ * A thin Fluxomni GraphQL transport with:
+ * - Session-aware HTTP and WebSocket setup
+ * - Direct raw GraphQL execution for automation scripts
+ * - Generated GraphQL documents and types for typed callers
+ * - Browser and server convenience helpers without a hand-written domain SDK
+ *
+ * @example
+ * ```typescript
+ * import { GraphQLClient, StateDocument } from '@fluxomni/api-client';
+ *
+ * // Create client
+ * const client = new GraphQLClient({
+ *   httpEndpoint: 'http://localhost:8001/api',
+ *   wsEndpoint: 'ws://localhost:8001/api/subscriptions',
+ * });
+ *
+ * const data = await client.executeRaw<{
+ *   routes: { allRoutes: Array<{ id: string; label?: string | null }> };
+ * }>(`
+ *   query Routes {
+ *     routes { allRoutes { id label } }
+ *   }
+ * `);
+ *
+ * // Subscribe to state changes
+ * client.subscribe({ query: StateDocument }).subscribe({
+ *   next: (result) => {
+ *     console.log('Routes updated:', result.data);
+ *   },
+ *   error: (err) => console.error(err),
+ * });
+ * ```
+ *
+ * @packageDocumentation
+ */
+// Low-level client
+export { createSessionFetch, login, SESSION_COOKIE_NAME, } from './auth.js';
+export { GraphQLClient, } from './client.js';
+// Errors
+export { classifyGraphQLError, ClientError, extractField, GraphQLError, MissingDataError, MissingFieldError, NetworkError, } from './errors.js';
+// Re-export all generated types for convenience
+export * from './generated/graphql.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,mBAAmB;AACnB,OAAO,EAIL,kBAAkB,EAGlB,KAAK,EACL,mBAAmB,GACpB,MAAM,WAAW,CAAC;AACnB,OAAO,EAEL,aAAa,GAId,MAAM,aAAa,CAAC;AACrB,SAAS;AACT,OAAO,EACL,oBAAoB,EACpB,WAAW,EACX,YAAY,EACZ,YAAY,EAGZ,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,GACb,MAAM,aAAa,CAAC;AACrB,gDAAgD;AAChD,cAAc,wBAAwB,CAAC"}

package/dist/scalars.d.ts

@@ -0,0 +1,5 @@
+/**
+ * RFC3339 timestamp returned by the GraphQL `DateTime` scalar.
+ */
+export type DateTime = string;
+//# sourceMappingURL=scalars.d.ts.map

package/dist/scalars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scalars.d.ts","sourceRoot":"","sources":["../src/scalars.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC"}

package/dist/scalars.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=scalars.js.map

package/dist/scalars.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scalars.js","sourceRoot":"","sources":["../src/scalars.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@fluxomni/api-client",
+  "version": "0.11.0",
+  "description": "TypeScript GraphQL client for Fluxomni API",
+  "type": "module",
+  "engines": {
+    "node": ">=24"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./generated": {
+      "types": "./dist/generated/graphql.d.ts",
+      "import": "./dist/generated/graphql.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "fmt": "pnpm -w exec biome format --write api/clients/typescript",
+    "lint": "pnpm -w exec biome lint api/clients/typescript && tsc --noEmit",
+    "test": "vitest run",
+    "examples:check": "pnpm run build && tsc --noEmit -p ../../examples/typescript/tsconfig.json",
+    "graphql:codegen": "graphql-codegen --config codegen.yml",
+    "prepublishOnly": "pnpm run clean && pnpm run build"
+  },
+  "devDependencies": {
+    "@apollo/client": "^3.13.0",
+    "@graphql-codegen/cli": "^6.0.1",
+    "@graphql-codegen/typed-document-node": "^6.1.0",
+    "@graphql-codegen/typescript": "^5.0.2",
+    "@graphql-codegen/typescript-operations": "^5.0.2",
+    "@graphql-tools/graphql-file-loader": "^8.1.5",
+    "@graphql-typed-document-node/core": "^3.2.0",
+    "graphql": "^16.13.1",
+    "graphql-ws": "^6.0.7",
+    "typescript": "^5.9",
+    "vitest": "^4.1.0"
+  },
+  "peerDependencies": {
+    "@apollo/client": ">=3.8",
+    "graphql": ">=16.0"
+  },
+  "keywords": [
+    "fluxomni",
+    "graphql",
+    "apollo",
+    "streaming",
+    "rtmp"
+  ],
+  "license": "PolyForm-Noncommercial-1.0.0"
+}

package/src/auth.ts

@@ -0,0 +1,127 @@
+export const SESSION_COOKIE_NAME = 'fluxomni_session';
+
+export type AuthRole = 'admin' | 'operator' | 'viewer';
+
+export type AuthUser = {
+  id: string;
+  username: string;
+  displayName: string | null;
+  role: AuthRole;
+};
+
+export type AuthStatus = {
+  authRequired: boolean;
+  authenticated: boolean;
+  role: AuthRole | null;
+  currentUser: AuthUser | null;
+  canAccessSettings: boolean;
+  canAccessFleet: boolean;
+};
+
+export type LoginOptions = {
+  username: string;
+  password: string;
+  /** Base server URL, for example `http://localhost:8001`. Defaults to same-origin `/api/auth/login`. */
+  baseUrl?: string;
+  /** Full auth endpoint override. Takes precedence over `baseUrl`. */
+  authEndpoint?: string;
+  /** Custom fetch implementation. */
+  fetch?: typeof fetch;
+  /** Browser credential mode for the login request. Defaults to `same-origin`. */
+  credentials?: RequestCredentials;
+};
+
+export type LoginResult = {
+  status: AuthStatus;
+  /** `Cookie` header value for server-side callers when the runtime exposes Set-Cookie. */
+  cookieHeader?: string;
+};
+
+export async function login(options: LoginOptions): Promise<LoginResult> {
+  const fetchFn = options.fetch ?? globalThis.fetch;
+  if (!fetchFn) {
+    throw new Error('A fetch implementation is required for login()');
+  }
+
+  const response = await fetchFn(resolveAuthEndpoint(options), {
+    method: 'POST',
+    credentials: options.credentials ?? 'same-origin',
+    headers: {
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify({
+      username: options.username,
+      password: options.password,
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(await readAuthError(response));
+  }
+
+  return {
+    status: (await response.json()) as AuthStatus,
+    cookieHeader: sessionCookieHeaderFromResponse(response),
+  };
+}
+
+export function createSessionFetch(
+  cookieHeader: string,
+  fetchFn: typeof fetch = globalThis.fetch,
+): typeof fetch {
+  return (input, init = {}) => {
+    const headers = new Headers(init.headers);
+    if (!headers.has('cookie')) {
+      headers.set('cookie', cookieHeader);
+    }
+
+    return fetchFn(input, {
+      ...init,
+      headers,
+    });
+  };
+}
+
+function resolveAuthEndpoint(options: LoginOptions): string {
+  if (options.authEndpoint) {
+    return options.authEndpoint;
+  }
+
+  if (options.baseUrl) {
+    return new URL('/api/auth/login', options.baseUrl).toString();
+  }
+
+  return '/api/auth/login';
+}
+
+function sessionCookieHeaderFromResponse(
+  response: Response,
+): string | undefined {
+  const setCookie = response.headers.get('set-cookie');
+  if (!setCookie) {
+    return undefined;
+  }
+
+  return sessionCookieHeaderFromSetCookie(setCookie);
+}
+
+function sessionCookieHeaderFromSetCookie(
+  setCookie: string,
+): string | undefined {
+  const cookiePair = setCookie
+    .split(',')
+    .map((part) => part.trim())
+    .find((part) => part.startsWith(`${SESSION_COOKIE_NAME}=`))
+    ?.split(';')[0];
+
+  return cookiePair && cookiePair.includes('=') ? cookiePair : undefined;
+}
+
+async function readAuthError(response: Response): Promise<string> {
+  try {
+    const body = (await response.json()) as { message?: string };
+    return body.message || `Authentication failed (${response.status})`;
+  } catch {
+    return `Authentication failed (${response.status})`;
+  }
+}