@dreamboard-games/api-client 0.1.0

package/dist/source-revisions.js

@@ -0,0 +1,174 @@
+import { createSourceBlobUploadSession } from "./sdk.gen.js";
+const textEncoder = new TextEncoder();
+function bytesToHex(bytes) {
+    return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function sha256Hex(bytes) {
+    const normalizedBytes = new Uint8Array(bytes.byteLength);
+    normalizedBytes.set(bytes);
+    const digest = await crypto.subtle.digest("SHA-256", normalizedBytes.buffer);
+    return bytesToHex(new Uint8Array(digest));
+}
+function getUtf8ByteSize(content) {
+    return textEncoder.encode(content).byteLength;
+}
+async function computeSourceContentHash(content) {
+    return sha256Hex(textEncoder.encode(content));
+}
+async function describeSourceBlob(content) {
+    return {
+        contentHash: await computeSourceContentHash(content),
+        byteSize: getUtf8ByteSize(content),
+    };
+}
+export async function materializeSourceChangeOperations(changes) {
+    const blobsByHash = new Map();
+    const materialized = await Promise.all(Array.from(changes, async (change) => {
+        if (change.kind === "delete") {
+            return change;
+        }
+        const blob = await describeSourceBlob(change.content);
+        const existing = blobsByHash.get(blob.contentHash);
+        if (!existing) {
+            blobsByHash.set(blob.contentHash, blob);
+        }
+        return {
+            kind: "upsert",
+            path: change.path,
+            contentHash: blob.contentHash,
+            byteSize: blob.byteSize,
+        };
+    }));
+    return {
+        blobs: Array.from(blobsByHash.values()).sort((left, right) => left.contentHash.localeCompare(right.contentHash)),
+        changes: materialized,
+    };
+}
+export function mapUpsertBlobContentsByContentHash(localChanges, materializedChanges) {
+    const uploadBlobs = new Map();
+    const length = Math.min(localChanges.length, materializedChanges.length);
+    for (let index = 0; index < length; index += 1) {
+        const localChange = localChanges[index];
+        const materializedChange = materializedChanges[index];
+        if (localChange?.kind !== "upsert" ||
+            materializedChange?.kind !== "upsert") {
+            continue;
+        }
+        uploadBlobs.set(materializedChange.contentHash, {
+            contentHash: materializedChange.contentHash,
+            byteSize: materializedChange.byteSize,
+            content: localChange.content,
+        });
+    }
+    return uploadBlobs;
+}
+class SourceBlobUploadError extends Error {
+    constructor(status, details) {
+        const suffix = details.trim().length > 0 ? `: ${details.trim()}` : "";
+        super(`Failed to upload source blob (HTTP ${status}${suffix})`);
+        this.name = "SourceBlobUploadError";
+        this.status = status;
+        this.details = details;
+    }
+}
+function isDuplicateDirectUploadError(error) {
+    if (!(error instanceof SourceBlobUploadError)) {
+        return false;
+    }
+    if (error.status === 409) {
+        return true;
+    }
+    const normalizedDetails = error.details.toLowerCase();
+    return (normalizedDetails.includes("duplicate") ||
+        normalizedDetails.includes("already exists") ||
+        normalizedDetails.includes("resource already exists"));
+}
+async function uploadSourceBlob(uploadTarget, content) {
+    const response = await fetch(uploadTarget.url, {
+        method: uploadTarget.method,
+        headers: uploadTarget.headers,
+        body: textEncoder.encode(content),
+    });
+    if (response.ok) {
+        return;
+    }
+    const details = await response.text().catch(() => "");
+    throw new SourceBlobUploadError(response.status, details);
+}
+export class SourceBlobSessionRequestError extends Error {
+    constructor(message, apiError, response) {
+        super(message);
+        this.name = "SourceBlobSessionRequestError";
+        this.apiError = apiError;
+        this.response = response;
+    }
+}
+async function confirmSourceBlobAlreadyExists(options) {
+    const { gameId, blob } = options;
+    const { data, error, response } = await createSourceBlobUploadSession({
+        path: { gameId },
+        body: {
+            blobs: [
+                {
+                    contentHash: blob.contentHash,
+                    byteSize: blob.byteSize,
+                },
+            ],
+        },
+    });
+    if (error || !data) {
+        throw new SourceBlobSessionRequestError("Failed to create source blob upload session", error, response);
+    }
+    return data.uploads[0]?.status === "exists";
+}
+export async function uploadGameSourceBlobs(options) {
+    const { gameId, blobs } = options;
+    const uniqueBlobs = new Map();
+    for (const blob of blobs) {
+        const existing = uniqueBlobs.get(blob.contentHash);
+        if (!existing) {
+            uniqueBlobs.set(blob.contentHash, blob);
+            continue;
+        }
+        if (existing.byteSize !== blob.byteSize) {
+            throw new Error(`Source blob ${blob.contentHash} has conflicting byte sizes.`);
+        }
+    }
+    if (uniqueBlobs.size === 0) {
+        return;
+    }
+    const { data, error, response } = await createSourceBlobUploadSession({
+        path: { gameId },
+        body: {
+            blobs: Array.from(uniqueBlobs.values(), ({ contentHash, byteSize }) => ({
+                contentHash,
+                byteSize,
+            })),
+        },
+    });
+    if (error || !data) {
+        throw new SourceBlobSessionRequestError("Failed to create source blob upload session", error, response);
+    }
+    for (const upload of data.uploads) {
+        if (upload.status !== "upload_required") {
+            continue;
+        }
+        const blob = uniqueBlobs.get(upload.contentHash);
+        if (!blob) {
+            throw new Error(`Upload session referenced unknown source blob ${upload.contentHash}.`);
+        }
+        if (!upload.uploadTarget) {
+            throw new Error(`Upload target missing for source blob ${upload.contentHash}.`);
+        }
+        try {
+            await uploadSourceBlob(upload.uploadTarget, blob.content);
+        }
+        catch (error) {
+            if (isDuplicateDirectUploadError(error) &&
+                (await confirmSourceBlobAlreadyExists({ gameId, blob }))) {
+                continue;
+            }
+            throw error;
+        }
+    }
+}

package/dist/storage-paths.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Storage path constants shared between frontend and backend.
+ * These mirror the values in the Kotlin StoragePathUtils.
+ */
+/**
+ * Storage bucket for compiled scripts (game logic and UI bundles)
+ */
+export declare const STORAGE_BUCKET = "scripts";
+/**
+ * Directory name for source files
+ */
+export declare const SOURCE_DIR = "src";
+/**
+ * Directory name for compiled output
+ */
+export declare const DIST_DIR = "dist";
+//# sourceMappingURL=storage-paths.d.ts.map

package/dist/storage-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-paths.d.ts","sourceRoot":"","sources":["../src/storage-paths.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,eAAO,MAAM,cAAc,YAAY,CAAC;AAExC;;GAEG;AACH,eAAO,MAAM,UAAU,QAAQ,CAAC;AAEhC;;GAEG;AACH,eAAO,MAAM,QAAQ,SAAS,CAAC"}

package/dist/storage-paths.js

@@ -0,0 +1,16 @@
+/**
+ * Storage path constants shared between frontend and backend.
+ * These mirror the values in the Kotlin StoragePathUtils.
+ */
+/**
+ * Storage bucket for compiled scripts (game logic and UI bundles)
+ */
+export const STORAGE_BUCKET = "scripts";
+/**
+ * Directory name for source files
+ */
+export const SOURCE_DIR = "src";
+/**
+ * Directory name for compiled output
+ */
+export const DIST_DIR = "dist";