@schematichq/schematic-typescript-node 1.4.0 → 1.4.2

package/README.md

@@ -601,6 +601,97 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
 }
 ```
 
+## DataStream
+
+DataStream enables local flag evaluation by maintaining a WebSocket connection to Schematic and caching flag rules, company, and user data locally.
+
+> **Runtime compatibility:** DataStream requires Node.js APIs (`WebSocket`, `EventEmitter`) and is not supported in edge runtimes such as Cloudflare Workers, Vercel Edge Functions, or Deno Deploy. For these runtimes, use [Replicator Mode](#replicator-mode) instead.
+
+### Setup
+
+```ts
+import { SchematicClient } from "@schematichq/schematic-typescript-node";
+
+const client = new SchematicClient({
+    apiKey: process.env.SCHEMATIC_API_KEY,
+    useDataStream: true,
+});
+
+// Flag checks are now evaluated locally
+const flagValue = await client.checkFlag(
+    { company: { id: "your-company-id" } },
+    "some-flag-key",
+);
+
+client.close();
+```
+
+### Configuration options
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `cacheTTL` | `number` | 24 hours | Cache TTL in milliseconds |
+| `redisClient` | `RedisClient` | — | Redis client for shared caching (uses in-memory cache if not provided) |
+| `redisKeyPrefix` | `string` | `schematic:` | Key prefix for Redis cache entries |
+
+```ts
+import { createClient } from "redis";
+import { SchematicClient } from "@schematichq/schematic-typescript-node";
+
+const redisClient = createClient({ url: "redis://localhost:6379" });
+await redisClient.connect();
+
+const client = new SchematicClient({
+    apiKey: process.env.SCHEMATIC_API_KEY,
+    useDataStream: true,
+    dataStream: {
+        redisClient,
+        redisKeyPrefix: "schematic:",
+        cacheTTL: 60 * 60 * 1000, // 1 hour
+    },
+});
+```
+
+## Replicator Mode
+
+Replicator mode is designed for environments where a separate process (the replicator) manages the WebSocket connection and populates a shared cache. The SDK reads from that cache and evaluates flags locally without establishing its own WebSocket connection.
+
+### Requirements
+
+Replicator mode requires a shared cache (Redis or custom cache providers) so the SDK can read data written by the external replicator process.
+
+### Setup
+
+```ts
+import { createClient } from "redis";
+import { SchematicClient } from "@schematichq/schematic-typescript-node";
+
+const redisClient = createClient({ url: "redis://localhost:6379" });
+await redisClient.connect();
+
+const client = new SchematicClient({
+    apiKey: process.env.SCHEMATIC_API_KEY,
+    useDataStream: true,
+    dataStream: {
+        replicatorMode: true,
+        redisClient,
+        replicatorHealthURL: "http://localhost:8080/health",
+        replicatorHealthCheck: 30000, // 30 seconds
+    },
+});
+```
+
+### Configuration options
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `replicatorMode` | `boolean` | `false` | Enable replicator mode |
+| `redisClient` | `RedisClient` | — | **Required.** Redis client for reading from the shared cache |
+| `redisKeyPrefix` | `string` | `schematic:` | Key prefix for Redis cache entries |
+| `replicatorHealthURL` | `string` | — | URL to poll for replicator health status |
+| `replicatorHealthCheck` | `number` | 30000 | Health check polling interval in milliseconds |
+| `cacheTTL` | `number` | 24 hours | Cache TTL in milliseconds |
+
 ## Testing
 
 ### Offline mode

package/dist/api/resources/billing/client/Client.d.ts

@@ -369,7 +369,6 @@ export declare class BillingClient {
      * @example
      *     await client.billing.upsertBillingProduct({
      *         externalId: "external_id",
-     *         name: "name",
      *         price: 1.1
      *     })
      */

package/dist/api/resources/billing/client/requests/CreateBillingProductRequestBody.d.ts

@@ -3,14 +3,13 @@ import type * as Schematic from "../../../../index";
  * @example
  *     {
  *         externalId: "external_id",
- *         name: "name",
  *         price: 1.1
  *     }
  */
 export interface CreateBillingProductRequestBody {
     externalId: string;
     isActive?: boolean;
-    name: string;
+    name?: string;
     price: number;
     providerType?: Schematic.BillingProviderType;
 }

package/dist/api/resources/plangroups/client/Client.d.ts

@@ -11,6 +11,7 @@ export declare class PlangroupsClient {
     protected readonly _options: NormalizedClientOptionsWithAuth<PlangroupsClient.Options>;
     constructor(options: PlangroupsClient.Options);
     /**
+     * @param {Schematic.GetPlanGroupRequest} request
      * @param {PlangroupsClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Schematic.UnauthorizedError}
@@ -19,9 +20,11 @@ export declare class PlangroupsClient {
      * @throws {@link Schematic.InternalServerError}
      *
      * @example
-     *     await client.plangroups.getPlanGroup()
+     *     await client.plangroups.getPlanGroup({
+     *         includeCompanyCounts: true
+     *     })
      */
-    getPlanGroup(requestOptions?: PlangroupsClient.RequestOptions): core.HttpResponsePromise<Schematic.GetPlanGroupResponse>;
+    getPlanGroup(request?: Schematic.GetPlanGroupRequest, requestOptions?: PlangroupsClient.RequestOptions): core.HttpResponsePromise<Schematic.GetPlanGroupResponse>;
     private __getPlanGroup;
     /**
      * @param {Schematic.CreatePlanGroupRequestBody} request

package/dist/api/resources/plangroups/client/requests/GetPlanGroupRequest.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @example
+ *     {
+ *         includeCompanyCounts: true
+ *     }
+ */
+export interface GetPlanGroupRequest {
+    includeCompanyCounts?: boolean;
+}

package/dist/api/resources/plangroups/client/requests/index.d.ts

@@ -1,2 +1,3 @@
 export type { CreatePlanGroupRequestBody } from "./CreatePlanGroupRequestBody";
+export type { GetPlanGroupRequest } from "./GetPlanGroupRequest";
 export type { UpdatePlanGroupRequestBody } from "./UpdatePlanGroupRequestBody";

package/dist/api/resources/plangroups/types/GetPlanGroupParams.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Input parameters
+ */
+export interface GetPlanGroupParams {
+    includeCompanyCounts?: boolean;
+}

package/dist/api/resources/plangroups/types/GetPlanGroupResponse.d.ts

@@ -2,5 +2,5 @@ import type * as Schematic from "../../../index";
 export interface GetPlanGroupResponse {
     data: Schematic.PlanGroupDetailResponseData;
     /** Input parameters */
-    params: Record<string, unknown>;
+    params: Schematic.GetPlanGroupParams;
 }

package/dist/api/resources/plangroups/types/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./CreatePlanGroupResponse";
+export * from "./GetPlanGroupParams";
 export * from "./GetPlanGroupResponse";
 export * from "./UpdatePlanGroupResponse";

package/dist/datastream/datastream-client.d.ts

@@ -1,6 +1,6 @@
-import { EventEmitter } from 'events';
 import * as Schematic from '../api/types';
 import { Logger } from '../logger';
+import { LazyEmitter } from './emitter';
 import type { CacheProvider } from '../cache/types';
 import { type RedisClient } from '../cache/redis';
 /**
@@ -36,7 +36,7 @@ export interface DataStreamClientOptions {
  * DataStreamClient provides a comprehensive client for Schematic's datastream
  * with caching, flag evaluation, and entity management matching the Go implementation
  */
-export declare class DataStreamClient extends EventEmitter {
+export declare class DataStreamClient extends LazyEmitter {
     private readonly apiKey;
     private readonly baseURL?;
     private readonly logger;

package/dist/datastream/emitter.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Minimal interface for the subset of EventEmitter we use.
+ * Avoids importing the Node.js `events` module at the top level
+ * so that edge runtimes (Cloudflare Workers, etc.) can load the
+ * module graph without error.
+ */
+export interface Emitter {
+    on(event: string, listener: (...args: any[]) => void): void;
+    emit(event: string, ...args: any[]): boolean;
+    removeAllListeners(event?: string): void;
+}
+/**
+ * Mixin base class that provides lazy-loaded EventEmitter composition.
+ * The Node.js `events` module is only required the first time a listener
+ * is registered or an event is emitted, keeping the import out of the
+ * module-level dependency graph.
+ */
+export declare class LazyEmitter {
+    private _emitter;
+    private ensureEmitter;
+    on(event: string, listener: (...args: any[]) => void): this;
+    emit(event: string, ...args: any[]): boolean;
+    removeAllListeners(event?: string): this;
+}

package/dist/datastream/websocket-client.d.ts

@@ -1,6 +1,6 @@
-import { EventEmitter } from 'events';
 import { DataStreamResp, DataStreamBaseReq } from './types';
 import { Logger } from '../logger';
+import { LazyEmitter } from './emitter';
 /**
  * MessageHandlerFunc is a function type for handling incoming datastream messages
  * Expects parsed DataStreamResp messages
@@ -34,7 +34,7 @@ export interface ClientOptions {
 /**
  * DatastreamWSClient represents a Schematic datastream websocket client with automatic reconnection
  */
-export declare class DatastreamWSClient extends EventEmitter {
+export declare class DatastreamWSClient extends LazyEmitter {
     private readonly url;
     private readonly headers;
     private readonly logger;