@schematichq/schematic-typescript-node 1.4.5 → 1.4.7

package/dist/core/url/QueryStringBuilder.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Creates a fluent builder for constructing URL query strings.
+ *
+ * Each `.add()` call serializes its value immediately (like C#'s builder),
+ * so no format tracking is needed — the style is applied at add-time.
+ *
+ * Usage (generated code):
+ *
+ *     const qs = core.url.queryBuilder()
+ *         .add("limit", limit)
+ *         .add("tags", tags, { style: "comma" })   // explode: false
+ *         .mergeAdditional(requestOptions?.queryParams)
+ *         .build();
+ */
+export declare function queryBuilder(): QueryStringBuilder;
+declare class QueryStringBuilder {
+    private parts;
+    /**
+     * Adds a query parameter, serializing it immediately.
+     *
+     * By default arrays use "repeat" format (`key=a&key=b`).
+     * Pass `{ style: "comma" }` for OpenAPI `explode: false` parameters
+     * to get comma-separated values (`key=a,b,c`).
+     *
+     * Null / undefined values are silently skipped.
+     */
+    add(key: string, value: unknown, options?: {
+        style?: "comma";
+    }): this;
+    /**
+     * Adds multiple query parameters at once from a record.
+     * All parameters use the default "repeat" array format.
+     * Null / undefined values are silently skipped.
+     */
+    addMany(params: Record<string, unknown>): this;
+    /**
+     * Merges additional query parameters supplied at call-time via
+     * `requestOptions.queryParams`. Overrides existing keys (last-write-wins).
+     */
+    mergeAdditional(additionalParams?: Record<string, unknown>): this;
+    /**
+     * Returns the assembled query string (without the leading `?`).
+     * Returns an empty string when no parameters were added.
+     */
+    build(): string;
+}
+export {};

package/dist/core/url/index.d.ts

@@ -1,3 +1,4 @@
 export { encodePathParam } from "./encodePathParam";
 export { join } from "./join";
+export { queryBuilder } from "./QueryStringBuilder";
 export { toQueryString } from "./qs";

package/dist/core/url/qs.d.ts

@@ -1,5 +1,6 @@
+type ArrayFormat = "indices" | "repeat" | "comma";
 interface QueryStringOptions {
-    arrayFormat?: "indices" | "repeat";
+    arrayFormat?: ArrayFormat;
     encode?: boolean;
 }
 export declare function toQueryString(obj: unknown, options?: QueryStringOptions): string;

package/dist/datastream/merge.d.ts

@@ -7,15 +7,19 @@ export declare function deepCopyCompany(c: Schematic.RulesengineCompany): Schema
  * Creates a complete deep copy of a User object.
  */
 export declare function deepCopyUser(u: Schematic.RulesengineUser): Schematic.RulesengineUser;
-/**
- * Extracts the "id" field from a parsed datastream message data object.
- * Throws if the id field is missing or empty.
- */
-export declare function extractIdFromData(data: Record<string, unknown>): string;
 /**
  * Merges a partial update into an existing Company.
  * Deep-copies the existing company, then applies only the fields
- * present in the partial object. The "id" field must be present.
+ * present in the partial object. Maps (keys, credit_balances) merge
+ * additively. Metrics are upserted by (eventSubtype, period, monthReset).
+ * All other fields replace the existing value. The original is not mutated.
+ *
+ * Partials don't carry refreshed entitlements, so when their derived fields
+ * change in another part of the company we sync them here to match server
+ * behavior:
+ *   - credit_remaining ← credit_balances[credit_id]
+ *   - usage ← metric value matching (event_name, metric_period, month_reset)
+ * Both are skipped when the partial also sends entitlements wholesale.
  *
  * Wire format uses snake_case keys. The existing company from cache
  * may have either camelCase or snake_case keys depending on how it
@@ -25,6 +29,6 @@ export declare function partialCompany(existing: Schematic.RulesengineCompany, p
 /**
  * Merges a partial update into an existing User.
  * Deep-copies the existing user, then applies only the fields
- * present in the partial object. The "id" field must be present.
+ * present in the partial object.
  */
 export declare function partialUser(existing: Schematic.RulesengineUser, partial: Record<string, unknown>): Schematic.RulesengineUser;

package/dist/datastream/types.d.ts

@@ -35,6 +35,7 @@ export interface DataStreamBaseReq {
  */
 export interface DataStreamResp {
     data: unknown;
+    entity_id?: string;
     entity_type: string;
     message_type: string;
 }

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

@@ -36,7 +36,7 @@ export interface ClientOptions {
  */
 export declare class DatastreamWSClient extends LazyEmitter {
     private readonly url;
-    private readonly headers;
+    readonly headers: Record<string, string>;
     private readonly logger;
     private readonly messageHandler;
     private readonly connectionReadyHandler?;

package/dist/errors/SchematicError.d.ts

@@ -3,10 +3,12 @@ export declare class SchematicError extends Error {
     readonly statusCode?: number;
     readonly body?: unknown;
     readonly rawResponse?: core.RawResponse;
-    constructor({ message, statusCode, body, rawResponse, }: {
+    readonly cause?: unknown;
+    constructor({ message, statusCode, body, rawResponse, cause, }: {
         message?: string;
         statusCode?: number;
         body?: unknown;
         rawResponse?: core.RawResponse;
+        cause?: unknown;
     });
 }

package/dist/errors/SchematicTimeoutError.d.ts

@@ -1,3 +1,6 @@
 export declare class SchematicTimeoutError extends Error {
-    constructor(message: string);
+    readonly cause?: unknown;
+    constructor(message: string, opts?: {
+        cause?: unknown;
+    });
 }

package/dist/event-capture.d.ts

@@ -0,0 +1,28 @@
+import { CreateEventRequestBody } from "./api";
+import type { FetchFunction } from "./core/fetcher/Fetcher";
+export declare const DEFAULT_EVENT_CAPTURE_BASE_URL = "https://c.schematichq.com";
+export interface EventCaptureClientOptions {
+    apiKey: string;
+    /** Fetcher created by the SchematicClient — reused so that offline mode,
+     *  default headers, and retry/logging behavior stay consistent. */
+    fetcher: FetchFunction;
+    /** Static headers to include on every request (e.g. X-Fern-SDK-Name,
+     *  X-Fern-SDK-Version) so the capture service receives the same SDK
+     *  identifying headers as the REST API. */
+    headers?: Record<string, string>;
+    baseUrl?: string;
+    timeoutMs?: number;
+}
+/**
+ * HTTP client for sending event batches directly to the Schematic event
+ * capture service (default: https://c.schematichq.com/batch).
+ */
+export declare class EventCaptureClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly timeoutMs;
+    private readonly fetcher;
+    private readonly headers;
+    constructor(options: EventCaptureClientOptions);
+    sendBatch(events: CreateEventRequestBody[]): Promise<void>;
+}

package/dist/events.d.ts

@@ -1,5 +1,5 @@
 import { CreateEventRequestBody } from "./api";
-import { EventsClient } from "./api/resources/events/client/Client";
+import { EventCaptureClient } from "./event-capture";
 import { Logger } from "./logger";
 interface EventBufferOptions {
     interval?: number;
@@ -11,7 +11,7 @@ interface EventBufferOptions {
 }
 declare class EventBuffer {
     private events;
-    private eventsApi;
+    private captureClient;
     private interval;
     private intervalId;
     private logger;
@@ -22,7 +22,7 @@ declare class EventBuffer {
     private shutdown;
     private stopped;
     private flushing;
-    constructor(eventsApi: EventsClient, opts?: EventBufferOptions);
+    constructor(captureClient: EventCaptureClient, opts?: EventBufferOptions);
     flush(): Promise<void>;
     push(event: CreateEventRequestBody): Promise<void>;
     stop(): Promise<void>;

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 export * as Schematic from "./api";
 export { LocalCache } from "./cache/local";
 export { RedisCacheProvider, type RedisClient } from "./cache/redis";
-export { SchematicClient, type CheckFlagWithEntitlementResponse } from "./wrapper";
+export { SchematicClient, type CheckFlagWithEntitlementResponse, type CheckFlagOptions, type TrackOptions, type IdentifyOptions, } from "./wrapper";
+export { ConsoleLogger, LogLevel, type Logger } from "./logger";
 export { SchematicEnvironment } from "./environments";
 export { SchematicError, SchematicTimeoutError } from "./errors";
 export { RulesEngineClient } from "./rules-engine";