@aerostack/sdk-web 0.2.0 → 0.3.1

package/src/sdk/models/shared/errorresponse.ts

@@ -18,10 +18,13 @@ export const Code = {
 } as const;
 export type Code = ClosedEnum<typeof Code>;
 
+/**
+ * Invalid request
+ */
 export type ErrorResponse = {
   code: Code;
-  details?: { [k: string]: any } | undefined;
   message: string;
+  details?: { [k: string]: any } | undefined;
 };
 
 /** @internal */
@@ -36,8 +39,8 @@ export const ErrorResponse$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   code: Code$inboundSchema,
-  details: z.record(z.any()).optional(),
   message: z.string(),
+  details: z.record(z.any()).optional(),
 });
 
 export function errorResponseFromJSON(

package/src/sdk/models/shared/index.ts

@@ -5,5 +5,7 @@
 export * from "./authresponse.js";
 export * from "./dbqueryresult.js";
 export * from "./errorresponse.js";
+export * from "./searchresult.js";
 export * from "./security.js";
+export * from "./typestats.js";
 export * from "./user.js";

package/src/sdk/models/shared/searchresult.ts

@@ -0,0 +1,39 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type SearchResult = {
+  id?: string | undefined;
+  content?: string | undefined;
+  score?: number | undefined;
+  type?: string | undefined;
+  metadata?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const SearchResult$inboundSchema: z.ZodType<
+  SearchResult,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string().optional(),
+  content: z.string().optional(),
+  score: z.number().optional(),
+  type: z.string().optional(),
+  metadata: z.record(z.any()).optional(),
+});
+
+export function searchResultFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchResult, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchResult$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchResult' from JSON`,
+  );
+}

package/src/sdk/models/shared/typestats.ts

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type TypeStats = {
+  type?: string | undefined;
+  count?: number | undefined;
+};
+
+/** @internal */
+export const TypeStats$inboundSchema: z.ZodType<
+  TypeStats,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.string().optional(),
+  count: z.number().int().optional(),
+});
+
+export function typeStatsFromJSON(
+  jsonString: string,
+): SafeParseResult<TypeStats, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TypeStats$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TypeStats' from JSON`,
+  );
+}

package/src/sdk/models/shared/user.ts

@@ -8,22 +8,22 @@ import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type User = {
-  createdAt?: Date | undefined;
-  email?: string | undefined;
   id?: string | undefined;
-  metadata?: { [k: string]: any } | undefined;
+  email?: string | undefined;
   name?: string | null | undefined;
+  createdAt?: Date | undefined;
+  metadata?: { [k: string]: any } | undefined;
 };
 
 /** @internal */
 export const User$inboundSchema: z.ZodType<User, z.ZodTypeDef, unknown> = z
   .object({
+    id: z.string().optional(),
+    email: z.string().optional(),
+    name: z.nullable(z.string()).optional(),
     createdAt: z.string().datetime({ offset: true }).transform(v => new Date(v))
       .optional(),
-    email: z.string().optional(),
-    id: z.string().optional(),
     metadata: z.record(z.any()).optional(),
-    name: z.nullable(z.string()).optional(),
   });
 
 export function userFromJSON(

package/src/sdk/realtime.ts

@@ -0,0 +1,199 @@
+export type RealtimeEvent = 'INSERT' | 'UPDATE' | 'DELETE' | '*';
+
+export interface RealtimeMessage {
+    type: string;
+    topic: string;
+    [key: string]: any;
+}
+
+export interface RealtimeSubscriptionOptions {
+    event?: RealtimeEvent;
+    filter?: Record<string, any>;
+}
+
+export type RealtimeCallback = (payload: any) => void;
+
+export class RealtimeSubscription {
+    private client: RealtimeClient;
+    private topic: string;
+    private options: RealtimeSubscriptionOptions;
+    private callbacks: Map<RealtimeEvent, Set<RealtimeCallback>> = new Map();
+    private isSubscribed: boolean = false;
+
+    constructor(client: RealtimeClient, topic: string, options: RealtimeSubscriptionOptions = {}) {
+        this.client = client;
+        this.topic = topic;
+        this.options = options;
+    }
+
+    on(event: RealtimeEvent, callback: RealtimeCallback): this {
+        if (!this.callbacks.has(event)) {
+            this.callbacks.set(event, new Set());
+        }
+        this.callbacks.get(event)!.add(callback);
+        return this;
+    }
+
+    subscribe(): this {
+        if (this.isSubscribed) return this;
+        this.client._send({
+            type: 'subscribe',
+            topic: this.topic,
+            filter: this.options.filter
+        });
+        this.isSubscribed = true;
+        return this;
+    }
+
+    unsubscribe(): void {
+        if (!this.isSubscribed) return;
+        this.client._send({
+            type: 'unsubscribe',
+            topic: this.topic
+        });
+        this.isSubscribed = false;
+        this.callbacks.clear();
+    }
+
+    /** @internal */
+    _emit(payload: any): void {
+        const event = payload.operation as RealtimeEvent;
+        const requestedEvent = this.options.event || '*';
+
+        if (requestedEvent === '*' || requestedEvent === event) {
+            // Emit to specific event listeners
+            this.callbacks.get(event)?.forEach(cb => cb(payload));
+            // Emit to catch-all listeners
+            this.callbacks.get('*')?.forEach(cb => cb(payload));
+        }
+    }
+}
+
+export class RealtimeClient {
+    private baseUrl: string;
+    private projectId: string;
+    private token?: string;
+    private userId?: string;
+    private apiKey?: string;
+    private ws: WebSocket | null = null;
+    private subscriptions: Map<string, RealtimeSubscription> = new Map();
+    private reconnectTimer: any = null;
+    private heartbeatTimer: any = null;
+    private reconnectAttempts: number = 0;
+
+    constructor(options: { baseUrl: string; projectId: string; token?: string; userId?: string; apiKey?: string }) {
+        this.baseUrl = options.baseUrl.replace(/^http/, 'ws') + '/realtime';
+        this.projectId = options.projectId || '';
+        if (options.token) this.token = options.token;
+        if (options.userId) this.userId = options.userId;
+        if (options.apiKey) this.apiKey = options.apiKey;
+    }
+
+    connect(): Promise<void> {
+        if (this.ws) return Promise.resolve();
+
+        return new Promise((resolve, reject) => {
+            const url = new URL(this.baseUrl);
+            if (this.apiKey) {
+                url.searchParams.set('apiKey', this.apiKey);
+            } else {
+                url.searchParams.set('projectId', this.projectId);
+            }
+            if (this.userId) url.searchParams.set('userId', this.userId);
+            if (this.token) url.searchParams.set('token', this.token);
+
+            this.ws = new WebSocket(url.toString());
+
+            this.ws.onopen = () => {
+                console.log('Aerostack Realtime Connected');
+                this.reconnectAttempts = 0;
+                this.startHeartbeat();
+                // Re-subscribe
+                for (const sub of this.subscriptions.values()) {
+                    sub.subscribe();
+                }
+                resolve();
+            };
+
+            this.ws.onmessage = (event) => {
+                try {
+                    const data = JSON.parse(event.data);
+                    this.handleMessage(data);
+                } catch (e) {
+                    console.error('Realtime message parse error:', e);
+                }
+            };
+
+            this.ws.onclose = () => {
+                console.log('Aerostack Realtime Disconnected');
+                this.stopHeartbeat();
+                this.ws = null;
+                this.scheduleReconnect();
+            };
+
+            this.ws.onerror = (err) => {
+                console.error('Realtime connection error:', err);
+                reject(err);
+            };
+        });
+    }
+
+    disconnect() {
+        if (this.ws) {
+            this.ws.close();
+        }
+        this.stopReconnect();
+    }
+
+    channel(topic: string, options: RealtimeSubscriptionOptions = {}): RealtimeSubscription {
+        const fullTopic = topic.includes('/') ? topic : `table/${topic}/${this.projectId}`;
+
+        let sub = this.subscriptions.get(fullTopic);
+        if (!sub) {
+            sub = new RealtimeSubscription(this, fullTopic, options);
+            this.subscriptions.set(fullTopic, sub);
+        }
+        return sub;
+    }
+
+    /** @internal */
+    _send(data: any) {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(data));
+        }
+    }
+
+    private handleMessage(data: RealtimeMessage) {
+        if (data.type === 'db_change' || data.type === 'chat_message') {
+            const sub = this.subscriptions.get(data.topic);
+            if (sub) {
+                sub._emit(data);
+            }
+        }
+    }
+
+    private startHeartbeat() {
+        this.heartbeatTimer = setInterval(() => {
+            this._send({ type: 'ping' });
+        }, 30000);
+    }
+
+    private stopHeartbeat() {
+        if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+    }
+
+    /** Exponential backoff with jitter: 1s → 2s → 4s → ... → 30s */
+    private scheduleReconnect() {
+        this.stopReconnect();
+        const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);
+        const jitter = delay * 0.3 * Math.random();
+        this.reconnectAttempts++;
+        this.reconnectTimer = setTimeout(() => {
+            this.connect().catch(() => { });
+        }, delay + jitter);
+    }
+
+    private stopReconnect() {
+        if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    }
+}

package/src/sdk/sdk.ts

@@ -12,9 +12,9 @@ import { Services } from "./services.js";
 import { Storage } from "./storage.js";
 
 export class SDK extends ClientSDK {
-  private _ai?: Ai;
-  get ai(): Ai {
-    return (this._ai ??= new Ai(this._options));
+  private _database?: Database;
+  get database(): Database {
+    return (this._database ??= new Database(this._options));
   }
 
   private _authentication?: Authentication;
@@ -27,23 +27,23 @@ export class SDK extends ClientSDK {
     return (this._cache ??= new Cache(this._options));
   }
 
-  private _database?: Database;
-  get database(): Database {
-    return (this._database ??= new Database(this._options));
-  }
-
   private _queue?: Queue;
   get queue(): Queue {
     return (this._queue ??= new Queue(this._options));
   }
 
-  private _services?: Services;
-  get services(): Services {
-    return (this._services ??= new Services(this._options));
-  }
-
   private _storage?: Storage;
   get storage(): Storage {
     return (this._storage ??= new Storage(this._options));
   }
+
+  private _ai?: Ai;
+  get ai(): Ai {
+    return (this._ai ??= new Ai(this._options));
+  }
+
+  private _services?: Services;
+  get services(): Services {
+    return (this._services ??= new Services(this._options));
+  }
 }

package/src/sdk/search.ts

@@ -0,0 +1,97 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { aiSearchConfigure } from "../funcs/aiSearchConfigure.js";
+import { aiSearchDelete } from "../funcs/aiSearchDelete.js";
+import { aiSearchDeleteByType } from "../funcs/aiSearchDeleteByType.js";
+import { aiSearchIngest } from "../funcs/aiSearchIngest.js";
+import { aiSearchListTypes } from "../funcs/aiSearchListTypes.js";
+import { aiSearchQuery } from "../funcs/aiSearchQuery.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "./models/operations/index.js";
+import { unwrapAsync } from "./types/fp.js";
+
+export class Search extends ClientSDK {
+  /**
+   * Ingest content into managed search index
+   */
+  async ingest(
+    request: operations.IngestRequestBody,
+    options?: RequestOptions,
+  ): Promise<operations.IngestResponseBody> {
+    return unwrapAsync(aiSearchIngest(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Search managed index
+   */
+  async query(
+    request: operations.QueryRequestBody,
+    options?: RequestOptions,
+  ): Promise<operations.QueryResponseBody> {
+    return unwrapAsync(aiSearchQuery(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Delete item by ID
+   */
+  async delete(
+    request: operations.DeleteRequestBody,
+    options?: RequestOptions,
+  ): Promise<operations.DeleteResponseBody> {
+    return unwrapAsync(aiSearchDelete(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Delete all items of a type
+   */
+  async deleteByType(
+    request: operations.DeleteByTypeRequestBody,
+    options?: RequestOptions,
+  ): Promise<operations.DeleteByTypeResponseBody> {
+    return unwrapAsync(aiSearchDeleteByType(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * List distinct types and counts
+   */
+  async listTypes(
+    options?: RequestOptions,
+  ): Promise<operations.ListTypesResponseBody> {
+    return unwrapAsync(aiSearchListTypes(
+      this,
+      options,
+    ));
+  }
+
+  /**
+   * Update search configuration
+   */
+  async configure(
+    request: operations.ConfigureRequestBody,
+    options?: RequestOptions,
+  ): Promise<operations.ConfigureResponseBody> {
+    return unwrapAsync(aiSearchConfigure(
+      this,
+      request,
+      options,
+    ));
+  }
+}