@constructive-io/sdk 0.25.0 → 0.25.2

package/esm/api/orm/realtime.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Realtime Manager - WebSocket subscription support
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+interface WsGraphQLError {
+    readonly message: string;
+    readonly [key: string]: unknown;
+}
+interface WsExecutionResult<TData = Record<string, unknown>> {
+    data?: TData | null;
+    errors?: readonly WsGraphQLError[];
+    extensions?: Record<string, unknown>;
+}
+interface WsSink<T> {
+    next(value: T): void;
+    error(error: unknown): void;
+    complete(): void;
+}
+/**
+ * Minimal interface matching the graphql-ws Client.
+ * Consumers pass a concrete instance via RealtimeConfig.client.
+ */
+export interface WsClient {
+    subscribe<TData = Record<string, unknown>>(payload: {
+        query: string;
+        variables?: Record<string, unknown>;
+    }, sink: WsSink<WsExecutionResult<TData>>): () => void;
+    dispose(): void;
+}
+/** The DML operation that triggered the subscription event */
+export type SubscriptionOperation = 'INSERT' | 'UPDATE' | 'DELETE';
+/** Connection state of the WebSocket */
+export type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting';
+/** Listener for connection state changes */
+export type ConnectionStateListener = (state: ConnectionState) => void;
+/** Function returned by subscribe() to cancel the subscription */
+export type Unsubscribe = () => void;
+/**
+ * A realtime subscription event delivered to the client.
+ *
+ * @typeParam T - The row type of the subscribed table
+ */
+export interface SubscriptionEvent<T> {
+    /** The DML operation that triggered this event */
+    operation: SubscriptionOperation;
+    /** The current row data (null for DELETE if row is no longer visible) */
+    data: T | null;
+    /** Previous field values (populated on UPDATE when available) */
+    previousValues?: Partial<T>;
+    /** Server-side timestamp of when the change occurred */
+    timestamp: string;
+}
+/**
+ * Options for creating a subscription.
+ *
+ * @typeParam T - The row type of the subscribed table
+ * @typeParam TFilter - The filter type for the table
+ */
+export interface SubscribeOptions<T, TFilter = Record<string, unknown>> {
+    /** Server-side filter to limit which events are delivered */
+    filter?: TFilter;
+    /** Called when a subscription event is received */
+    onEvent: (event: SubscriptionEvent<T>) => void;
+    /** Called when the subscription encounters an error */
+    onError?: (error: Error) => void;
+    /** Called when the subscription completes (server-initiated close) */
+    onComplete?: () => void;
+}
+/**
+ * Metadata about a subscription field, used internally to map
+ * table names to GraphQL subscription field names and types.
+ */
+export interface SubscriptionFieldMeta {
+    /** The GraphQL subscription field name (e.g., 'onContactChanged') */
+    fieldName: string;
+    /** The table name in the source schema (e.g., 'contact') */
+    tableName: string;
+    /** The data field name inside the subscription payload (e.g., 'contact') */
+    dataFieldName: string;
+}
+/**
+ * Configuration for the realtime (WebSocket) connection.
+ * Pass this as the `realtime` option in OrmClientConfig.
+ *
+ * @example
+ * ```ts
+ * import { createClient } from 'graphql-ws';
+ *
+ * const client = createOrmClient({
+ *   endpoint: 'https://api.example.com/graphql',
+ *   realtime: {
+ *     client: createClient({ url: 'wss://api.example.com/graphql' }),
+ *   },
+ * });
+ * ```
+ */
+export interface RealtimeConfig {
+    /**
+     * A graphql-ws Client instance (or any object satisfying WsClient).
+     * The consumer creates this themselves, giving full control over
+     * connection options, auth, and transport.
+     *
+     * @example
+     * ```ts
+     * import { createClient } from 'graphql-ws';
+     * const wsClient = createClient({ url: 'wss://...' });
+     * ```
+     */
+    client: WsClient;
+}
+/**
+ * Manages a graphql-ws WebSocket client and multiplexes
+ * subscriptions over it. Created by OrmClient when `realtime`
+ * config is provided.
+ */
+export declare class RealtimeManager {
+    private wsClient;
+    private connectionState;
+    private stateListeners;
+    private activeSubscriptions;
+    constructor(config: RealtimeConfig);
+    /**
+     * Subscribe to a GraphQL subscription operation.
+     * Models call this with typed metadata and documents.
+     */
+    subscribe<T>(meta: SubscriptionFieldMeta, document: string, variables: Record<string, unknown>, options: {
+        onEvent: (event: SubscriptionEvent<T>) => void;
+        onError?: (error: Error) => void;
+        onComplete?: () => void;
+    }): Unsubscribe;
+    /** Register a listener for connection state changes */
+    onConnectionStateChange(listener: ConnectionStateListener): Unsubscribe;
+    /** Get current connection state */
+    getConnectionState(): ConnectionState;
+    /** Number of active subscriptions */
+    getActiveSubscriptionCount(): number;
+    /** Dispose the manager and close the WebSocket connection */
+    dispose(): void;
+    private setConnectionState;
+}
+export {};

package/esm/api/orm/realtime.js

@@ -0,0 +1,100 @@
+/**
+ * Realtime Manager - WebSocket subscription support
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+// Minimal type shims so this module compiles without graphql-ws
+// installed.  Consumers supply a WsClient via RealtimeConfig;
+// the SDK itself never imports or requires graphql-ws.
+// ============================================================================
+// RealtimeManager
+// ============================================================================
+/**
+ * Manages a graphql-ws WebSocket client and multiplexes
+ * subscriptions over it. Created by OrmClient when `realtime`
+ * config is provided.
+ */
+export class RealtimeManager {
+    wsClient;
+    connectionState = 'disconnected';
+    stateListeners = new Set();
+    activeSubscriptions = 0;
+    constructor(config) {
+        this.wsClient = config.client;
+    }
+    /**
+     * Subscribe to a GraphQL subscription operation.
+     * Models call this with typed metadata and documents.
+     */
+    subscribe(meta, document, variables, options) {
+        this.activeSubscriptions++;
+        let disposed = false;
+        const cleanup = this.wsClient.subscribe({ query: document, variables }, {
+            next: (result) => {
+                if (disposed)
+                    return;
+                if (result.errors) {
+                    options.onError?.(new Error(result.errors.map((e) => e.message).join('; ')));
+                    return;
+                }
+                const payload = result.data?.[meta.fieldName];
+                if (!payload)
+                    return;
+                const event = {
+                    operation: payload.event ?? 'UPDATE',
+                    data: payload[meta.dataFieldName] ?? null,
+                    previousValues: payload.previousValues,
+                    timestamp: payload.timestamp ?? new Date().toISOString(),
+                };
+                options.onEvent(event);
+            },
+            error: (err) => {
+                if (disposed)
+                    return;
+                options.onError?.(err instanceof Error ? err : new Error(String(err)));
+            },
+            complete: () => {
+                if (disposed)
+                    return;
+                options.onComplete?.();
+            },
+        });
+        return () => {
+            if (disposed)
+                return;
+            disposed = true;
+            this.activeSubscriptions--;
+            cleanup();
+        };
+    }
+    /** Register a listener for connection state changes */
+    onConnectionStateChange(listener) {
+        this.stateListeners.add(listener);
+        return () => {
+            this.stateListeners.delete(listener);
+        };
+    }
+    /** Get current connection state */
+    getConnectionState() {
+        return this.connectionState;
+    }
+    /** Number of active subscriptions */
+    getActiveSubscriptionCount() {
+        return this.activeSubscriptions;
+    }
+    /** Dispose the manager and close the WebSocket connection */
+    dispose() {
+        this.wsClient.dispose();
+        this.stateListeners.clear();
+        this.activeSubscriptions = 0;
+        this.setConnectionState('disconnected');
+    }
+    setConnectionState(state) {
+        if (this.connectionState === state)
+            return;
+        this.connectionState = state;
+        for (const listener of this.stateListeners) {
+            listener(state);
+        }
+    }
+}

package/esm/api/orm/select-types.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Type utilities for select inference
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+export interface ConnectionResult<T> {
+    nodes: T[];
+    totalCount: number;
+    pageInfo: PageInfo;
+}
+export interface PageInfo {
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    startCursor?: string | null;
+    endCursor?: string | null;
+}
+export interface FindManyArgs<TSelect, TWhere, TOrderBy> {
+    select?: TSelect;
+    where?: TWhere;
+    orderBy?: TOrderBy[];
+    first?: number;
+    last?: number;
+    after?: string;
+    before?: string;
+    offset?: number;
+}
+export interface FindFirstArgs<TSelect, TWhere, TOrderBy> {
+    select?: TSelect;
+    where?: TWhere;
+    orderBy?: TOrderBy[];
+}
+export interface CreateArgs<TSelect, TData> {
+    data: TData;
+    select?: TSelect;
+}
+export interface UpdateArgs<TSelect, TWhere, TData> {
+    where: TWhere;
+    data: TData;
+    select?: TSelect;
+}
+export type FindOneArgs<TSelect, TIdName extends string = 'id', TId = string> = {
+    select?: TSelect;
+} & Record<TIdName, TId>;
+export interface DeleteArgs<TWhere, TSelect = undefined> {
+    where: TWhere;
+    select?: TSelect;
+}
+export interface BulkInsertArgs<TSelect, TData, TOnConflict = unknown> {
+    data: TData[];
+    select?: TSelect;
+    onConflict?: TOnConflict;
+}
+export interface BulkUpsertArgs<TSelect, TData, TOnConflict = unknown> {
+    data: TData[];
+    select?: TSelect;
+    onConflict: TOnConflict;
+}
+export interface BulkUpdateArgs<TSelect, TWhere, TData> {
+    where: TWhere;
+    data: TData;
+    select?: TSelect;
+}
+export interface BulkDeleteArgs<TSelect, TWhere> {
+    where: TWhere;
+    select?: TSelect;
+}
+export interface BulkMutationResult<T> {
+    affectedCount: number;
+    returning: T[];
+}
+type DepthLevel = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;
+type DecrementDepth = {
+    0: 0;
+    1: 0;
+    2: 1;
+    3: 2;
+    4: 3;
+    5: 4;
+    6: 5;
+    7: 6;
+    8: 7;
+    9: 8;
+    10: 9;
+};
+/**
+ * Recursively validates select objects, rejecting unknown keys.
+ *
+ * NOTE: Depth is intentionally capped to avoid circular-instantiation issues
+ * in very large cyclic schemas.
+ */
+export type DeepExact<T, Shape, Depth extends DepthLevel = 10> = Depth extends 0 ? T extends Shape ? T : never : T extends Shape ? Exclude<keyof T, keyof Shape> extends never ? {
+    [K in keyof T]: K extends keyof Shape ? T[K] extends {
+        select: infer NS;
+    } ? Extract<Shape[K], {
+        select?: unknown;
+    }> extends {
+        select?: infer ShapeNS;
+    } ? DeepExact<Omit<T[K], 'select'> & {
+        select: DeepExact<NS, NonNullable<ShapeNS>, DecrementDepth[Depth]>;
+    }, Extract<Shape[K], {
+        select?: unknown;
+    }>, DecrementDepth[Depth]> : never : T[K] : never;
+} : never : never;
+/**
+ * Enforces exact select shape while keeping contextual typing on `S extends XxxSelect`.
+ * Use this as an intersection in overloads:
+ * `{ select: S } & StrictSelect<S, XxxSelect>`.
+ */
+export type StrictSelect<S, Shape> = S extends DeepExact<S, Shape> ? {} : never;
+/**
+ * Hook-optimized strict select variant.
+ *
+ * Uses a shallower recursion depth to keep editor autocomplete responsive
+ * in large schemas while still validating common nested-select mistakes.
+ */
+export type HookStrictSelect<S, Shape> = S extends DeepExact<S, Shape, 5> ? {} : never;
+/**
+ * Infer result type from select configuration
+ */
+export type InferSelectResult<TEntity, TSelect> = TSelect extends undefined ? TEntity : {
+    [K in keyof TSelect as TSelect[K] extends false | undefined ? never : K]: TSelect[K] extends true ? K extends keyof TEntity ? TEntity[K] : never : TSelect[K] extends {
+        select: infer NestedSelect;
+    } ? K extends keyof TEntity ? NonNullable<TEntity[K]> extends ConnectionResult<infer NodeType> ? ConnectionResult<InferSelectResult<NodeType, NestedSelect>> : InferSelectResult<NonNullable<TEntity[K]>, NestedSelect> | (null extends TEntity[K] ? null : never) : never : K extends keyof TEntity ? TEntity[K] : never;
+};
+export {};

package/esm/api/orm/select-types.js

@@ -0,0 +1 @@
+export {};

package/esm/api/orm/types.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Types re-export
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+export * from './input-types';

package/esm/api/orm/types.js

@@ -0,0 +1,7 @@
+/**
+ * Types re-export
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+// Re-export all types from input-types
+export * from './input-types';

package/esm/index.d.ts

@@ -7,6 +7,9 @@
  * @generated by @constructive-io/graphql-codegen
  */
 export * as admin from './admin';
+export * as agent from './agent';
+export * as api from './api';
 export * as auth from './auth';
+export * as modules from './modules';
 export * as objects from './objects';
-export * as public_ from './public';
+export * as usage from './usage';

package/esm/index.js

@@ -7,6 +7,9 @@
  * @generated by @constructive-io/graphql-codegen
  */
 export * as admin from './admin';
+export * as agent from './agent';
+export * as api from './api';
 export * as auth from './auth';
+export * as modules from './modules';
 export * as objects from './objects';
-export * as public_ from './public';
+export * as usage from './usage';

package/esm/modules/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * GraphQL SDK - auto-generated, do not edit
+ * @generated by @constructive-io/graphql-codegen
+ */
+export * from './orm';

package/esm/modules/index.js

@@ -0,0 +1,5 @@
+/**
+ * GraphQL SDK - auto-generated, do not edit
+ * @generated by @constructive-io/graphql-codegen
+ */
+export * from './orm';

package/esm/modules/orm/client.d.ts

@@ -0,0 +1,97 @@
+/**
+ * ORM Client - Runtime GraphQL executor
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import type { GraphQLAdapter, GraphQLError, QueryResult } from '@constructive-io/graphql-query/runtime';
+import type { ConnectionState, ConnectionStateListener, RealtimeConfig, SubscriptionEvent, SubscriptionFieldMeta, Unsubscribe } from './realtime';
+export type { GraphQLAdapter, GraphQLError, QueryResult, } from '@constructive-io/graphql-query/runtime';
+export type { ConnectionState, ConnectionStateListener, RealtimeConfig, SubscribeOptions, SubscriptionEvent, SubscriptionFieldMeta, SubscriptionOperation, Unsubscribe, WsClient, } from './realtime';
+export { RealtimeManager } from './realtime';
+/**
+ * Default adapter that uses fetch for HTTP requests.
+ *
+ * When no custom fetch is provided, uses @constructive-io/fetch which
+ * handles *.localhost DNS rewriting and Host header preservation in
+ * Node.js. Pass a custom fetch to override for test mocking or custom
+ * proxy/credentials.
+ */
+export declare class FetchAdapter implements GraphQLAdapter {
+    private endpoint;
+    private headers;
+    private fetchFn;
+    constructor(endpoint: string, headers?: Record<string, string>, fetchFn?: typeof globalThis.fetch);
+    execute<T>(document: string, variables?: Record<string, unknown>): Promise<QueryResult<T>>;
+    setHeaders(headers: Record<string, string>): void;
+    getEndpoint(): string;
+}
+/**
+ * Configuration for creating an ORM client.
+ * Either provide endpoint (and optional headers/fetch) for HTTP requests,
+ * or provide a custom adapter for alternative execution strategies.
+ */
+export interface OrmClientConfig {
+    /** GraphQL endpoint URL (required if adapter not provided) */
+    endpoint?: string;
+    /** Default headers for HTTP requests (only used with endpoint) */
+    headers?: Record<string, string>;
+    /**
+     * Custom fetch implementation. Defaults to createFetch() from
+     * @constructive-io/graphql-query/runtime which handles *.localhost
+     * DNS and Host headers in Node.js. Pass your own for test mocking
+     * or custom proxy/credentials.
+     */
+    fetch?: typeof globalThis.fetch;
+    /** Custom adapter for GraphQL execution (overrides endpoint/headers/fetch) */
+    adapter?: GraphQLAdapter;
+    /**
+     * Optional realtime (WebSocket) configuration.
+     * When provided, enables subscription methods on models.
+     * The WebSocket connection is created lazily on first subscribe().
+     */
+    realtime?: RealtimeConfig;
+}
+/**
+ * Error thrown when GraphQL request fails
+ */
+export declare class GraphQLRequestError extends Error {
+    readonly errors: GraphQLError[];
+    readonly data: unknown;
+    constructor(errors: GraphQLError[], data?: unknown);
+}
+export declare class OrmClient {
+    private adapter;
+    private realtimeManager?;
+    constructor(config: OrmClientConfig);
+    execute<T>(document: string, variables?: Record<string, unknown>): Promise<QueryResult<T>>;
+    /**
+     * Subscribe to a GraphQL subscription operation.
+     * Used by generated model subscribe() methods.
+     * @throws Error if realtime is not configured
+     */
+    subscribe<T>(meta: SubscriptionFieldMeta, document: string, variables: Record<string, unknown>, options: {
+        onEvent: (event: SubscriptionEvent<T>) => void;
+        onError?: (error: Error) => void;
+        onComplete?: () => void;
+    }): Unsubscribe;
+    /**
+     * Set headers for requests.
+     * Only works if the adapter supports headers.
+     */
+    setHeaders(headers: Record<string, string>): void;
+    /**
+     * Get the endpoint URL.
+     * Returns empty string if the adapter doesn't have an endpoint.
+     */
+    getEndpoint(): string;
+    /** Get current WebSocket connection state */
+    getConnectionState(): ConnectionState;
+    /** Register a listener for WebSocket connection state changes */
+    onConnectionStateChange(listener: ConnectionStateListener): Unsubscribe;
+    /** Number of active subscriptions */
+    getActiveSubscriptionCount(): number;
+    /** Whether realtime is configured */
+    get isRealtimeEnabled(): boolean;
+    /** Dispose the realtime manager (close WebSocket) */
+    dispose(): void;
+}

package/esm/modules/orm/client.js

@@ -0,0 +1,145 @@
+import { createFetch } from '@constructive-io/graphql-query/runtime';
+import { RealtimeManager } from './realtime';
+export { RealtimeManager } from './realtime';
+/**
+ * Default adapter that uses fetch for HTTP requests.
+ *
+ * When no custom fetch is provided, uses @constructive-io/fetch which
+ * handles *.localhost DNS rewriting and Host header preservation in
+ * Node.js. Pass a custom fetch to override for test mocking or custom
+ * proxy/credentials.
+ */
+export class FetchAdapter {
+    endpoint;
+    headers;
+    fetchFn;
+    constructor(endpoint, headers, fetchFn) {
+        this.endpoint = endpoint;
+        this.headers = headers ?? {};
+        this.fetchFn = (fetchFn ?? createFetch()).bind(globalThis);
+    }
+    async execute(document, variables) {
+        const response = await this.fetchFn(this.endpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+                ...this.headers,
+            },
+            body: JSON.stringify({
+                query: document,
+                variables: variables ?? {},
+            }),
+        });
+        if (!response.ok) {
+            return {
+                ok: false,
+                data: null,
+                errors: [{ message: `HTTP ${response.status}: ${response.statusText}` }],
+            };
+        }
+        const json = (await response.json());
+        if (json.errors && json.errors.length > 0) {
+            return {
+                ok: false,
+                data: null,
+                errors: json.errors,
+            };
+        }
+        return {
+            ok: true,
+            data: json.data,
+            errors: undefined,
+        };
+    }
+    setHeaders(headers) {
+        this.headers = { ...this.headers, ...headers };
+    }
+    getEndpoint() {
+        return this.endpoint;
+    }
+}
+/**
+ * Error thrown when GraphQL request fails
+ */
+export class GraphQLRequestError extends Error {
+    errors;
+    data;
+    constructor(errors, data = null) {
+        const messages = errors.map((e) => e.message).join('; ');
+        super(`GraphQL Error: ${messages}`);
+        this.errors = errors;
+        this.data = data;
+        this.name = 'GraphQLRequestError';
+    }
+}
+export class OrmClient {
+    adapter;
+    realtimeManager;
+    constructor(config) {
+        if (config.adapter) {
+            this.adapter = config.adapter;
+        }
+        else if (config.endpoint) {
+            this.adapter = new FetchAdapter(config.endpoint, config.headers, config.fetch);
+        }
+        else {
+            throw new Error('OrmClientConfig requires either an endpoint or a custom adapter');
+        }
+        if (config.realtime) {
+            this.realtimeManager = new RealtimeManager(config.realtime);
+        }
+    }
+    async execute(document, variables) {
+        return this.adapter.execute(document, variables);
+    }
+    /**
+     * Subscribe to a GraphQL subscription operation.
+     * Used by generated model subscribe() methods.
+     * @throws Error if realtime is not configured
+     */
+    subscribe(meta, document, variables, options) {
+        if (!this.realtimeManager) {
+            throw new Error('Realtime not configured. Pass a `realtime` option to createClient() to enable subscriptions.');
+        }
+        return this.realtimeManager.subscribe(meta, document, variables, options);
+    }
+    /**
+     * Set headers for requests.
+     * Only works if the adapter supports headers.
+     */
+    setHeaders(headers) {
+        if (this.adapter.setHeaders) {
+            this.adapter.setHeaders(headers);
+        }
+    }
+    /**
+     * Get the endpoint URL.
+     * Returns empty string if the adapter doesn't have an endpoint.
+     */
+    getEndpoint() {
+        return this.adapter.getEndpoint?.() ?? '';
+    }
+    /** Get current WebSocket connection state */
+    getConnectionState() {
+        return this.realtimeManager?.getConnectionState() ?? 'disconnected';
+    }
+    /** Register a listener for WebSocket connection state changes */
+    onConnectionStateChange(listener) {
+        if (!this.realtimeManager)
+            return () => { };
+        return this.realtimeManager.onConnectionStateChange(listener);
+    }
+    /** Number of active subscriptions */
+    getActiveSubscriptionCount() {
+        return this.realtimeManager?.getActiveSubscriptionCount() ?? 0;
+    }
+    /** Whether realtime is configured */
+    get isRealtimeEnabled() {
+        return this.realtimeManager !== undefined;
+    }
+    /** Dispose the realtime manager (close WebSocket) */
+    dispose() {
+        this.realtimeManager?.dispose();
+    }
+}