@astrogate/sdk 0.0.0-stage → 0.1.0

package/node_modules/@instantdb/core/dist/esm/StorageAPI.d.ts

@@ -0,0 +1,39 @@
+export type UploadFileResponse = {
+    data: {
+        id: string;
+    };
+};
+export type DeleteFileResponse = {
+    data: {
+        id: string | null;
+    };
+};
+export declare function uploadFile({ apiURI, appId, path, file, refreshToken, contentType, contentDisposition, }: {
+    apiURI: string;
+    appId: string;
+    path: string;
+    file: File | Blob;
+    refreshToken?: string;
+    contentType?: string;
+    contentDisposition?: string;
+}): Promise<UploadFileResponse>;
+export declare function deleteFile({ apiURI, appId, path, refreshToken, }: {
+    apiURI: string;
+    appId: string;
+    path: string;
+    refreshToken?: string;
+}): Promise<DeleteFileResponse>;
+export declare function getSignedUploadUrl({ apiURI, appId, fileName, refreshToken, metadata, }: {
+    apiURI: string;
+    appId: string;
+    fileName: string;
+    refreshToken?: string;
+    metadata?: Record<string, any>;
+}): Promise<any>;
+export declare function upload(presignedUrl: any, file: any): Promise<boolean>;
+export declare function getDownloadUrl({ apiURI, appId, path, refreshToken, }: {
+    apiURI: string;
+    appId: string;
+    path: string;
+    refreshToken?: string;
+}): Promise<any>;

package/node_modules/@instantdb/core/dist/esm/StorageAPI.js

@@ -0,0 +1,65 @@
+import { jsonFetch } from './utils/fetch.js';
+export async function uploadFile({ apiURI, appId, path, file, refreshToken, contentType, contentDisposition, }) {
+    const headers = {
+        'app-id': appId,
+        app_id: appId,
+        path,
+        authorization: `Bearer ${refreshToken}`,
+        'content-type': contentType || file.type,
+    };
+    if (contentDisposition) {
+        headers['content-disposition'] = contentDisposition;
+    }
+    const data = await jsonFetch(`${apiURI}/storage/upload`, {
+        method: 'PUT',
+        headers,
+        body: file,
+    });
+    return data;
+}
+export async function deleteFile({ apiURI, appId, path, refreshToken, }) {
+    const { data } = await jsonFetch(`${apiURI}/storage/files?app_id=${appId}&filename=${encodeURIComponent(path)}`, {
+        method: 'DELETE',
+        headers: {
+            'content-type': 'application/json',
+            authorization: `Bearer ${refreshToken}`,
+        },
+    });
+    return data;
+}
+// Deprecated Storage API (Jan 2025)
+// ---------------------------------
+export async function getSignedUploadUrl({ apiURI, appId, fileName, refreshToken, metadata = {}, }) {
+    const { data } = await jsonFetch(`${apiURI}/storage/signed-upload-url`, {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/json',
+            authorization: `Bearer ${refreshToken}`,
+        },
+        body: JSON.stringify({
+            app_id: appId,
+            filename: fileName,
+        }),
+    });
+    return data;
+}
+export async function upload(presignedUrl, file) {
+    const response = await fetch(presignedUrl, {
+        method: 'PUT',
+        body: file,
+        headers: {
+            'Content-Type': file.type,
+        },
+    });
+    return response.ok;
+}
+export async function getDownloadUrl({ apiURI, appId, path, refreshToken, }) {
+    const { data } = await jsonFetch(`${apiURI}/storage/signed-download-url?app_id=${appId}&filename=${encodeURIComponent(path)}`, {
+        method: 'GET',
+        headers: {
+            'content-type': 'application/json',
+            authorization: `Bearer ${refreshToken}`,
+        },
+    });
+    return data;
+}

package/node_modules/@instantdb/core/dist/esm/Stream.d.ts

@@ -0,0 +1,120 @@
+import { Logger } from './utils/log.ts';
+import { RuleParams } from './schemaTypes.ts';
+export type WritableStreamCtor = {
+    new <W = any>(underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>): WritableStream<W>;
+};
+export type ReadableStreamCtor = {
+    new <R = any>(underlyingSource?: UnderlyingDefaultSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
+};
+export interface InstantWritableStream<T> extends WritableStream<T> {
+    streamId: () => Promise<string>;
+}
+export interface InstantReadableStream<T> extends ReadableStream<T> {
+    streamId: () => Promise<string>;
+}
+type StartStreamMsg = {
+    op: 'start-stream';
+    'client-id': string;
+    'reconnect-token': string;
+    'rule-params'?: RuleParams;
+};
+type AppendStreamMsg = {
+    op: 'append-stream';
+    'stream-id': string;
+    chunks: string[];
+    offset: number;
+    done: boolean;
+    'abort-reason'?: string;
+};
+type SubscribeStreamMsg = {
+    op: 'subscribe-stream';
+    'stream-id'?: string;
+    'client-id'?: string;
+    offset?: number;
+    'rule-params'?: RuleParams;
+};
+type UnsubscribeStreamMsg = {
+    op: 'unsubscribe-stream';
+    'subscribe-event-id': string;
+};
+type SendMsg = StartStreamMsg | AppendStreamMsg | SubscribeStreamMsg | UnsubscribeStreamMsg;
+type TrySend = (eventId: string, msg: SendMsg) => void;
+type StartStreamOkMsg = {
+    op: 'start-stream-ok';
+    'client-event-id': string;
+    'stream-id': string;
+    offset: number;
+};
+type AppendStreamFailedMsg = {
+    op: 'append-failed';
+    'stream-id': string;
+};
+type StreamFlushedMsg = {
+    op: 'stream-flushed';
+    'stream-id': string;
+    offset: number;
+    done: boolean;
+};
+type StreamAppendMsg = {
+    op: 'stream-append';
+    'stream-id': string;
+    'client-id': string | null;
+    'client-event-id': string;
+    files?: {
+        url: string;
+        size: number;
+    }[];
+    done?: boolean;
+    'abort-reason'?: string;
+    offset: number;
+    error?: string;
+    retry: boolean;
+    content?: string;
+};
+type HandleRecieveErrorMsg = {
+    'client-event-id': string;
+    'original-event': SendMsg;
+    message?: string;
+    hint?: Record<string, any>;
+    type?: string;
+};
+export declare class InstantStream {
+    private trySend;
+    private WStream;
+    private RStream;
+    private writeStreams;
+    private startWriteStreamCbs;
+    private readStreamIterators;
+    private log;
+    private activeStreams;
+    constructor({ WStream, RStream, trySend, log, }: {
+        WStream: WritableStreamCtor;
+        RStream: ReadableStreamCtor;
+        trySend: TrySend;
+        log: Logger;
+    });
+    createWriteStream(opts: {
+        clientId: string;
+        waitUntil?: (promise: Promise<any>) => void | null | undefined;
+        ruleParams?: RuleParams | null | undefined;
+    }): InstantWritableStream<string>;
+    createReadStream(opts: {
+        clientId?: string | null | undefined;
+        streamId?: string | null | undefined;
+        byteOffset?: number | null | undefined;
+        ruleParams?: RuleParams | null | undefined;
+    }): InstantReadableStream<string>;
+    private startWriteStream;
+    private registerWriteStream;
+    private appendStream;
+    onAppendFailed(msg: AppendStreamFailedMsg): void;
+    onStartStreamOk(msg: StartStreamOkMsg): void;
+    onStreamFlushed(msg: StreamFlushedMsg): void;
+    private startReadStream;
+    private cancelReadStream;
+    onStreamAppend(msg: StreamAppendMsg): void;
+    onConnectionStatusChange(status: any): void;
+    onRecieveError(msg: HandleRecieveErrorMsg): void;
+    hasActiveStreams(): boolean;
+}
+export {};