@oore/client 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aryakumar Jha
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,156 @@
+# `@oore/client`
+
+Typed, tree-shakeable JavaScript client for the Oore API. It is generated from Oore's OpenAPI schema and adds small Oore-owned APIs for client setup, errors, log streaming, React Query, MSW, and Valibot.
+
+## Core client
+
+```ts
+import {
+  createOoreClient,
+  listProjects,
+  OoreApiError,
+} from '@oore/client'
+
+const client = createOoreClient({
+  baseUrl: 'http://127.0.0.1:8787',
+  token: () => session.getAccessToken(),
+})
+
+try {
+  const result = await listProjects({
+    client,
+    query: { limit: 20, search: 'mobile' },
+  })
+  console.log(result.projects)
+} catch (error) {
+  if (error instanceof OoreApiError) {
+    console.error(error.status, error.code, error.message)
+  }
+}
+```
+
+Each call accepts an explicit client. This keeps clients for separate Oore daemons isolated and makes custom `fetch`, headers, credentials, and token refresh easy to supply.
+
+## React Query
+
+Install `@tanstack/react-query` when using this entrypoint.
+
+```ts
+import { useQuery } from '@tanstack/react-query'
+import { createOoreClient } from '@oore/client/client'
+import {
+  listProjectsOptions,
+  useListProjectsQuery,
+} from '@oore/client/react-query'
+
+const client = createOoreClient({ baseUrl: 'http://127.0.0.1:8787' })
+
+// The main API: portable query options for hooks, loaders, prefetching, and tests.
+const projectsQuery = listProjectsOptions({ client, query: { limit: 20 } })
+const result = useQuery(projectsQuery)
+
+// Generated convenience hooks call the same option factory.
+const sameResult = useListProjectsQuery({ client, query: { limit: 20 } })
+```
+
+Query keys, query option factories, mutation option factories, and hooks are generated for every compatible operation.
+
+## MSW
+
+Install `msw` when using these entrypoints.
+
+Use a generated handler factory when a test needs exact control:
+
+```ts
+import { HttpResponse } from 'msw'
+import { setupServer } from 'msw/node'
+import { listProjectsMock } from '@oore/client/msw'
+
+const server = setupServer(
+  listProjectsMock(() =>
+    HttpResponse.json({ projects: [], total: 0 }),
+  ),
+)
+```
+
+Use the deterministic Oore scenario for demos and broader flows:
+
+```ts
+import { setupServer } from 'msw/node'
+import { createOoreMockHandlers } from '@oore/client/msw/scenarios'
+
+const server = setupServer(...createOoreMockHandlers())
+```
+
+The default scenario owns a fresh copy of its state each time. Creating a project changes later project-list responses. The data and timestamps are fixed, not random.
+
+## Valibot
+
+Install `valibot` when using this entrypoint.
+
+```ts
+import * as v from 'valibot'
+import { vProject } from '@oore/client/valibot'
+
+const result = v.safeParse(vProject, input)
+```
+
+Each Valibot schema is emitted as its own module, so importing one public schema does not retain all generated schemas.
+
+## Build logs and install manifests
+
+```ts
+import {
+  createOoreClient,
+  getIosInstallManifestText,
+  streamBuildLogEvents,
+} from '@oore/client'
+
+const client = createOoreClient({ baseUrl: 'http://127.0.0.1:8787' })
+
+for await (const event of streamBuildLogEvents({
+  client,
+  path: { build_id: 'build-1' },
+})) {
+  if (event.type === 'log') console.log(event.chunk.content)
+}
+
+const plist = await getIosInstallManifestText({
+  client,
+  path: { token: 'download-token' },
+})
+```
+
+The manifest helper parses Oore's XML response as text. The generated low-level operation remains available when a `Blob` is preferred.
+
+## Entrypoints
+
+| Import | Contents |
+| --- | --- |
+| `@oore/client` | Client setup, errors, all operations and models, SSE and XML helpers |
+| `@oore/client/client` | Client setup and errors only |
+| `@oore/client/operations` | Generated operation functions |
+| `@oore/client/models` | Generated TypeScript models |
+| `@oore/client/logs` | Typed build-log stream helper |
+| `@oore/client/react-query` | React Query keys, option factories, and hooks |
+| `@oore/client/msw` | Generated MSW handler factories |
+| `@oore/client/msw/scenarios` | Deterministic, stateful Oore scenarios |
+| `@oore/client/valibot` | Generated Valibot schemas |
+
+The root entrypoint does not load React Query, MSW, or Valibot. The package has no default export and declares `sideEffects: false`.
+
+## Generation
+
+```sh
+bun install --frozen-lockfile
+bun run fetch-schema
+bun run check
+```
+
+Generation pins `@hey-api/openapi-ts`, TypeScript, and all adapter versions. The coverage check requires all OpenAPI operations and component schemas to appear in their matching package surfaces.
+
+## Releases
+
+GitHub Actions checks every pull request and every push to `main`. A daily scheduled workflow fetches `https://docs.oore.build/openapi.json`; when the schema changes, it regenerates the package, runs the full check, and opens or updates a reviewable pull request.
+
+Conventional commits feed Release Please. Merging its version pull request creates a GitHub Release, reruns the package checks from that tag, and publishes `@oore/client` through npm trusted publishing. GitHub Actions are pinned to immutable commits and the publish job uses no long-lived npm token.

package/dist/artifacts.d.ts

@@ -0,0 +1,7 @@
+import { getIosInstallManifest, getIosInstallManifestV1 } from './generated/sdk.gen.js';
+export type GetIosInstallManifestTextOptions = Parameters<typeof getIosInstallManifest>[0];
+export type GetIosInstallManifestV1TextOptions = Parameters<typeof getIosInstallManifestV1>[0];
+/** Returns the iOS installation manifest as XML text instead of a Blob. */
+export declare const getIosInstallManifestText: (options: GetIosInstallManifestTextOptions) => Promise<string>;
+/** Returns the legacy iOS installation manifest as XML text instead of a Blob. */
+export declare const getIosInstallManifestV1Text: (options: GetIosInstallManifestV1TextOptions) => Promise<string>;

package/dist/artifacts.js

@@ -0,0 +1,8 @@
+import { getIosInstallManifest, getIosInstallManifestV1, } from './generated/sdk.gen.js';
+/** Returns the iOS installation manifest as XML text instead of a Blob. */
+export const getIosInstallManifestText = async (options) => (await getIosInstallManifest({ ...options, parseAs: 'text' }));
+/** Returns the legacy iOS installation manifest as XML text instead of a Blob. */
+export const getIosInstallManifestV1Text = async (options) => (await getIosInstallManifestV1({
+    ...options,
+    parseAs: 'text',
+}));

package/dist/client.d.ts

@@ -0,0 +1,28 @@
+import type { Client, Config } from './generated/client/index.js';
+export type OoreClient = Client;
+export type OoreToken = string | (() => Promise<string | undefined> | string | undefined);
+export interface OoreClientOptions extends Omit<Config, 'auth' | 'baseUrl' | 'parseAs' | 'responseStyle' | 'throwOnError'> {
+    /** Base URL of the Oore daemon, for example `http://127.0.0.1:8787`. */
+    baseUrl: string;
+    /** Bearer token or a function that resolves the current token. */
+    token?: OoreToken;
+}
+export interface OoreApiErrorOptions {
+    cause?: unknown;
+    code?: string | undefined;
+    details?: string | null | undefined;
+    request?: Request | undefined;
+    response: Response;
+}
+/** A non-2xx response returned by an Oore daemon. */
+export declare class OoreApiError extends Error {
+    readonly code: string | undefined;
+    readonly details: string | null | undefined;
+    readonly request: Request | undefined;
+    readonly response: Response;
+    readonly status: number;
+    constructor(message: string, options: OoreApiErrorOptions);
+}
+export declare const isOoreApiError: (error: unknown) => error is OoreApiError;
+/** Creates an isolated client for one Oore daemon. */
+export declare const createOoreClient: (options: OoreClientOptions) => OoreClient;

package/dist/client.js

@@ -0,0 +1,63 @@
+import { createClient } from './generated/client/index.js';
+/** A non-2xx response returned by an Oore daemon. */
+export class OoreApiError extends Error {
+    code;
+    details;
+    request;
+    response;
+    status;
+    constructor(message, options) {
+        super(message, { cause: options.cause });
+        this.name = 'OoreApiError';
+        this.code = options.code;
+        this.details = options.details;
+        this.request = options.request;
+        this.response = options.response;
+        this.status = options.response.status;
+    }
+}
+export const isOoreApiError = (error) => error instanceof OoreApiError;
+const isApiErrorBody = (value) => {
+    if (!value || typeof value !== 'object')
+        return false;
+    const body = value;
+    return typeof body.code === 'string' && typeof body.error === 'string';
+};
+const normalizeBaseUrl = (baseUrl) => {
+    const normalized = baseUrl.trim().replace(/\/+$/, '');
+    if (!normalized)
+        throw new TypeError('Oore client baseUrl must not be empty');
+    return normalized;
+};
+/** Creates an isolated client for one Oore daemon. */
+export const createOoreClient = (options) => {
+    const { baseUrl, credentials = 'include', token, ...config } = options;
+    const client = createClient({
+        ...config,
+        auth: typeof token === 'function'
+            ? async () => (await token()) ?? undefined
+            : token,
+        baseUrl: normalizeBaseUrl(baseUrl),
+        credentials,
+        parseAs: 'auto',
+        responseStyle: 'data',
+        throwOnError: true,
+    });
+    client.interceptors.error.use((error, response, request) => {
+        if (!response || error instanceof OoreApiError)
+            return error;
+        const body = isApiErrorBody(error) ? error : undefined;
+        const message = body?.error ||
+            (typeof error === 'string' && error) ||
+            response.statusText ||
+            `Oore request failed with status ${response.status}`;
+        return new OoreApiError(message, {
+            cause: error,
+            code: body?.code,
+            details: body?.details,
+            request,
+            response,
+        });
+    });
+    return client;
+};