@kokimoki/app 0.1.0 → 0.2.1

package/dist/index.d.ts

@@ -1,11 +1,8 @@
-import { KokimokiClient } from "./kokimoki-client";
-import { UserMediaHandler } from "./user-media-handler";
-export * from "./types/api";
 export * from "./types/tasks";
 export * from "./types/common";
 export * from "./types/events";
+export * from "./types/upload";
 export * from "./fields";
 export * from "./kokimoki-client";
 export * from "./synced-store";
-export declare const kmClient: KokimokiClient<any>;
-export declare const userMediaHandler: UserMediaHandler;
+export * from "./user-media-handler";

package/dist/index.js

@@ -1,11 +1,8 @@
-import { KokimokiClient } from "./kokimoki-client";
-import { UserMediaHandler } from "./user-media-handler";
-export * from "./types/api";
 export * from "./types/tasks";
 export * from "./types/common";
 export * from "./types/events";
+export * from "./types/upload";
 export * from "./fields";
 export * from "./kokimoki-client";
 export * from "./synced-store";
-export const kmClient = new KokimokiClient();
-export const userMediaHandler = new UserMediaHandler();
+export * from "./user-media-handler";

package/dist/kokimoki-client.d.ts

@@ -2,7 +2,6 @@ import { HocuspocusProvider } from "@hocuspocus/provider";
 import type TypedEmitter from "typed-emitter";
 import type { SyncedStore } from "./synced-store";
 import type { DocTypeDescription } from "@syncedstore/core/types/doc";
-import type { UploadedMedia } from "./types/api";
 import type { KokimokiClientEvents } from "./types/events";
 declare const KokimokiClient_base: new <T>() => TypedEmitter<KokimokiClientEvents<T>>;
 export declare class KokimokiClient<StatelessDataT = any> extends KokimokiClient_base<StatelessDataT> {
@@ -10,12 +9,14 @@ export declare class KokimokiClient<StatelessDataT = any> extends KokimokiClient
     private _appId?;
     private _wsUrl?;
     private _apiUrl?;
-    private _id;
-    private _token;
+    private _id?;
+    private _token?;
     private _providers;
     constructor();
     get id(): string;
+    get appId(): string;
     get token(): string;
+    get apiUrl(): string;
     connect(host: string, appId: string): Promise<void>;
     setProvider<T extends DocTypeDescription>(name: string, store: SyncedStore<T>): Promise<void>;
     removeProvider(name: string): void;
@@ -23,6 +24,6 @@ export declare class KokimokiClient<StatelessDataT = any> extends KokimokiClient
     serverTimestamp(): number;
     sendStatelessToClient(room: string, clientId: string, data: StatelessDataT): void;
     sendStatelessToRoom(room: string, data: StatelessDataT, self?: boolean): void;
-    mediaUpload(blob: Blob): Promise<UploadedMedia>;
 }
+export declare const kmClient: KokimokiClient<any>;
 export {};

package/dist/kokimoki-client.js

@@ -1,17 +1,12 @@
 import { HocuspocusProvider } from "@hocuspocus/provider";
 import EventEmitter from "events";
-import { sendMediaUpload } from "./api/sendMediaUpload";
-import { getETags } from "./api/getETags";
-import { uploadMedia } from "./api/uploadMedia";
-import { errorMessage } from "./utils";
-import { fetchAuth } from "./api/fetchAuth";
 export class KokimokiClient extends EventEmitter {
     serverTimeOffset = 0;
     _appId;
     _wsUrl;
     _apiUrl;
-    _id = "";
-    _token = "";
+    _id;
+    _token;
     _providers = new Map();
     constructor() {
         super();
@@ -22,12 +17,24 @@ export class KokimokiClient extends EventEmitter {
         }
         return this._id;
     }
+    get appId() {
+        if (!this._appId) {
+            throw new Error("Client not connected");
+        }
+        return this._appId;
+    }
     get token() {
         if (!this._token) {
             throw new Error("Client not connected");
         }
         return this._token;
     }
+    get apiUrl() {
+        if (!this._apiUrl) {
+            throw new Error("Client not connected");
+        }
+        return this._apiUrl;
+    }
     async connect(host, appId) {
         this._appId = appId;
         // Set up the URLs
@@ -37,11 +44,14 @@ export class KokimokiClient extends EventEmitter {
         // Fetch the auth token
         let clientToken = localStorage.getItem("KM_TOKEN");
         const startTime = Date.now();
-        const { clientId, appToken, serverTime, token } = await fetchAuth({
-            appId,
-            clientToken,
-            apiUrl: this._apiUrl,
+        const res = await fetch(`${this.apiUrl}/auth/token?appId=${appId}`, {
+            method: "GET",
+            headers: new Headers({
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${clientToken}`,
+            }),
         });
+        const { clientId, appToken, serverTime, token } = await res.json();
         const endTime = Date.now();
         const ping = Math.round((endTime - startTime) / 2);
         this._id = clientId;
@@ -102,22 +112,5 @@ export class KokimokiClient extends EventEmitter {
         }
         provider.sendStateless(JSON.stringify({ data, self }));
     }
-    async mediaUpload(blob) {
-        if (!this._apiUrl) {
-            throw new Error("Client not connected");
-        }
-        try {
-            const uploadData = await sendMediaUpload(blob, {
-                apiUrl: this._apiUrl,
-                appToken: this.token,
-            });
-            const { id } = uploadData;
-            const etags = await getETags(blob, uploadData);
-            const { url } = await uploadMedia({ id, etags }, { apiUrl: this._apiUrl, appToken: this.token });
-            return { url, id };
-        }
-        catch (error) {
-            throw new Error(`Error while uploading media: ${errorMessage(error)}`);
-        }
-    }
 }
+export const kmClient = new KokimokiClient();

package/dist/kokimoki-storage.d.ts

@@ -0,0 +1,13 @@
+import type { Paginated } from "./types/common";
+import type { Upload } from "./types/upload";
+export declare class KokimokiStorage {
+    private createUpload;
+    private uploadChunks;
+    private completeUpload;
+    upload(name: string, blob: Blob, tags?: string[]): Promise<Upload>;
+    listUploads(filter?: {
+        clientId?: string;
+        mimeTypes?: string[];
+    }, skip?: number, limit?: number): Promise<Paginated<Upload>>;
+}
+export declare const kmStorage: KokimokiStorage;

package/dist/kokimoki-storage.js

@@ -0,0 +1,63 @@
+import { kmClient } from "./kokimoki-client";
+export class KokimokiStorage {
+    async createUpload(name, blob, tags) {
+        const res = await fetch(`${kmClient.apiUrl}/uploads`, {
+            method: "POST",
+            headers: new Headers({
+                Authorization: `Bearer ${kmClient.token}`,
+                "Content-Type": "application/json",
+            }),
+            body: JSON.stringify({
+                name,
+                size: blob.size,
+                mimeType: blob.type,
+                tags,
+            }),
+        });
+        return await res.json();
+    }
+    async uploadChunks(blob, chunkSize, signedUrls) {
+        return await Promise.all(signedUrls.map(async (url, index) => {
+            const start = index * chunkSize;
+            const end = Math.min(start + chunkSize, blob.size);
+            const chunk = blob.slice(start, end);
+            const res = await fetch(url, { method: "PUT", body: chunk });
+            return JSON.parse(res.headers.get("ETag") || '""');
+        }));
+    }
+    async completeUpload(id, etags) {
+        const res = await fetch(`${kmClient.apiUrl}/uploads/${id}`, {
+            method: "PUT",
+            headers: new Headers({
+                Authorization: `Bearer ${kmClient.token}`,
+                "Content-Type": "application/json",
+            }),
+            body: JSON.stringify({ etags }),
+        });
+        return await res.json();
+    }
+    async upload(name, blob, tags = []) {
+        const { id, chunkSize, urls } = await this.createUpload(name, blob, tags);
+        const etags = await this.uploadChunks(blob, chunkSize, urls);
+        return await this.completeUpload(id, etags);
+    }
+    async listUploads(filter = {}, skip = 0, limit = 100) {
+        const url = new URL("/uploads", kmClient.apiUrl);
+        url.searchParams.set("skip", skip.toString());
+        url.searchParams.set("limit", limit.toString());
+        if (filter.clientId) {
+            url.searchParams.set("clientId", filter.clientId);
+        }
+        if (filter.mimeTypes) {
+            url.searchParams.set("mimeTypes", filter.mimeTypes.join());
+        }
+        const res = await fetch(url.href, {
+            headers: new Headers({
+                Authorization: `Bearer ${kmClient.token}`,
+                "Content-Type": "application/json",
+            }),
+        });
+        return await res.json();
+    }
+}
+export const kmStorage = new KokimokiStorage();

package/dist/types/common.d.ts

@@ -1 +1,5 @@
 export type FacingMode = "user" | "environment";
+export interface Paginated<T> {
+    items: T[];
+    total: number;
+}

package/dist/types/upload.d.ts

@@ -0,0 +1,12 @@
+export interface Upload {
+    id: string;
+    appId: string;
+    clientId: string;
+    createdAt: Date;
+    name: string;
+    url: string;
+    size: number;
+    mimeType: string;
+    completed: boolean;
+    tags: string[];
+}

package/dist/types/upload.js

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

package/dist/user-media-handler.d.ts

@@ -12,4 +12,5 @@ export declare class UserMediaHandler extends UserMediaHandler_base {
     setFacingMode(facingMode: "user" | "environment"): void;
     toggleFacingMode(): void;
 }
+export declare const userMediaHandler: UserMediaHandler;
 export {};

package/dist/user-media-handler.js

@@ -59,3 +59,4 @@ export class UserMediaHandler extends EventEmitter {
         this.setFacingMode(this._facingMode === "user" ? "environment" : "user");
     }
 }
+export const userMediaHandler = new UserMediaHandler();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kokimoki/app",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "type": "module",
   "description": "Kokimoki app",
   "main": "dist/index.js",