@crowdedkingdoms/crowdyjs 9.0.0 → 10.0.0

package/dist/domains/playerCodeProjects.js

@@ -0,0 +1,299 @@
+import { CrowdyGraphQLError, CrowdyHttpError, CrowdyNetworkError, CrowdyTimeoutError, } from '../errors.js';
+import { ModStudioOfflineError, ModStudioRevisionConflictError, normalizeModStudioPath, } from '../mod-studio/models.js';
+import { PlayerCodeCommonFilesDocument, PlayerCodeImportSource, PlayerCodeLibraryFilesDocument, PlayerCodeLibrarySaveDocument, PlayerCodePairingPreference, PlayerCodeProjectCreateDocument, PlayerCodeProjectDocument, PlayerCodeProjectImportFileDocument, PlayerCodeProjectSaveDocument, PlayerCodeProjectsDocument, } from '../generated/graphql.js';
+/**
+ * Typed Game API adapter for private Mod Studio projects and reusable files.
+ * Mutable projects remain separate from immutable player-compute versions;
+ * only the controller's deploy path converts target files to sourceFilesJson.
+ */
+export class PlayerCodeProjectsAPI {
+    constructor(graphql) {
+        this.graphql = graphql;
+        this.baselines = new Map();
+    }
+    async listProjects(scope) {
+        const data = await this.request(PlayerCodeProjectsDocument, {
+            appId: scope.appId,
+            includeArchived: false,
+            limit: 50,
+            offset: 0,
+        });
+        return data.playerCodeProjects.map(fromSummaryDto);
+    }
+    async getProject(input) {
+        const data = await this.request(PlayerCodeProjectDocument, {
+            appId: input.appId,
+            projectId: input.projectId,
+        });
+        return this.remember(fromProjectDto(data.playerCodeProject, input.gridId));
+    }
+    async createProject(input) {
+        const data = await this.request(PlayerCodeProjectCreateDocument, {
+            input: {
+                appId: input.appId,
+                gridId: input.gridId,
+                name: input.metadata.name,
+                description: input.metadata.description ?? null,
+                serverModuleName: input.metadata.serverModuleName ?? null,
+                clientModuleName: input.metadata.clientModuleName ?? null,
+                pairingPreference: toApiPairing(input.kind, input.metadata.pairingPreference),
+                sdkVersion: '0.1.5',
+                abiVersion: 0,
+                initialFiles: input.files.map(toApiFile),
+            },
+        });
+        return this.remember(fromProjectDto(data.playerCodeProjectCreate, input.gridId));
+    }
+    async saveProject(input) {
+        try {
+            const baseline = this.baselines.get(input.projectId) ??
+                (await this.getProject({
+                    appId: input.appId,
+                    gridId: input.gridId,
+                    projectId: input.projectId,
+                }));
+            const delta = projectFileDelta(baseline, input);
+            const data = await this.request(PlayerCodeProjectSaveDocument, {
+                input: {
+                    appId: input.appId,
+                    projectId: input.projectId,
+                    expectedRevision: input.expectedRevisionId,
+                    gridId: input.gridId,
+                    name: input.metadata.name,
+                    description: input.metadata.description ?? null,
+                    serverModuleName: input.metadata.serverModuleName ?? null,
+                    clientModuleName: input.metadata.clientModuleName ?? null,
+                    pairingPreference: toApiPairing(projectKind(input), input.metadata.pairingPreference),
+                    upserts: delta.upserts.map(toApiFile),
+                    deletes: delta.deletes.map(({ target, path }) => ({
+                        target: target,
+                        path,
+                    })),
+                },
+            });
+            return this.remember(fromProjectDto(data.playerCodeProjectSave, input.gridId));
+        }
+        catch (error) {
+            if (error instanceof CrowdyGraphQLError &&
+                error.code === 'CONFLICT' &&
+                error.message.includes('PLAYER_CODE_REVISION_CONFLICT')) {
+                let remoteProject;
+                try {
+                    remoteProject = await this.getProject({
+                        appId: input.appId,
+                        gridId: input.gridId,
+                        projectId: input.projectId,
+                    });
+                }
+                catch {
+                    // The conflict remains actionable if the follow-up read fails.
+                }
+                throw new ModStudioRevisionConflictError(error.message, remoteProject);
+            }
+            throw error;
+        }
+    }
+    async listPersonalLibraryFiles(scope) {
+        const data = await this.request(PlayerCodeLibraryFilesDocument, {
+            appId: scope.appId,
+            includeArchived: false,
+            limit: 100,
+            offset: 0,
+        });
+        return data.playerCodeLibraryFiles.map(fromLibraryDto);
+    }
+    async savePersonalLibraryFile(input) {
+        const data = await this.request(PlayerCodeLibrarySaveDocument, {
+            input: {
+                appId: input.appId,
+                title: input.title,
+                pathHint: normalizeModStudioPath(input.path),
+                target: input.target,
+                tags: input.tags ?? [],
+                content: input.content,
+            },
+        });
+        return fromLibraryDto(data.playerCodeLibrarySave);
+    }
+    async listCommonFiles(scope) {
+        const data = await this.request(PlayerCodeCommonFilesDocument, {
+            appId: scope.appId,
+            limit: 100,
+            offset: 0,
+        });
+        return data.playerCodeCommonFiles.map(fromCommonDto);
+    }
+    async importReferenceFile(input) {
+        const data = await this.request(PlayerCodeProjectImportFileDocument, {
+            input: {
+                appId: input.appId,
+                projectId: input.projectId,
+                expectedProjectRevision: input.expectedRevisionId,
+                source: input.source === 'PERSONAL_LIBRARY'
+                    ? PlayerCodeImportSource.Library
+                    : PlayerCodeImportSource.Common,
+                ...(input.source === 'PERSONAL_LIBRARY'
+                    ? { libraryFileId: input.referenceId }
+                    : { commonVersionId: input.referenceId }),
+                ...(input.destinationPath
+                    ? { destinationPath: normalizeModStudioPath(input.destinationPath) }
+                    : {}),
+            },
+        });
+        return this.remember(fromProjectDto(data.playerCodeProjectImportFile, input.gridId));
+    }
+    remember(project) {
+        this.baselines.set(project.projectId, cloneProject(project));
+        return project;
+    }
+    async request(document, variables) {
+        try {
+            return await this.graphql.request(document, variables);
+        }
+        catch (error) {
+            if (error instanceof CrowdyNetworkError ||
+                error instanceof CrowdyTimeoutError ||
+                (error instanceof CrowdyHttpError && error.status >= 500)) {
+                throw new ModStudioOfflineError(error.message, error);
+            }
+            throw error;
+        }
+    }
+}
+function fromSummaryDto(dto) {
+    return {
+        projectId: dto.projectId,
+        name: dto.name,
+        kind: kindFromApi(dto.pairingPreference),
+        revisionId: String(dto.revision),
+        ...(dto.serverModuleName
+            ? { serverModuleName: dto.serverModuleName }
+            : {}),
+        ...(dto.clientModuleName
+            ? { clientModuleName: dto.clientModuleName }
+            : {}),
+        updatedAt: dto.updatedAt,
+    };
+}
+function fromProjectDto(dto, fallbackGridId) {
+    const files = dto.files.map((file) => ({
+        target: file.target,
+        path: normalizeModStudioPath(file.path),
+        content: file.content,
+    }));
+    return {
+        projectId: dto.projectId,
+        appId: String(dto.appId),
+        gridId: dto.gridId == null ? fallbackGridId : String(dto.gridId),
+        kind: kindFromApi(dto.pairingPreference),
+        metadata: {
+            name: dto.name,
+            ...(dto.description ? { description: dto.description } : {}),
+            ...(dto.serverModuleName
+                ? { serverModuleName: dto.serverModuleName }
+                : {}),
+            ...(dto.clientModuleName
+                ? { clientModuleName: dto.clientModuleName }
+                : {}),
+            pairingPreference: fromApiPairing(dto.pairingPreference),
+        },
+        files,
+        sdkVersion: dto.sdkVersion,
+        abiVersion: dto.abiVersion,
+        revision: {
+            id: String(dto.revision),
+            savedAt: dto.updatedAt,
+        },
+        createdAt: dto.createdAt,
+        updatedAt: dto.updatedAt,
+    };
+}
+function fromLibraryDto(dto) {
+    return {
+        id: dto.libraryFileId,
+        source: 'PERSONAL_LIBRARY',
+        title: dto.title,
+        target: dto.target,
+        path: normalizeModStudioPath(dto.pathHint),
+        content: dto.content,
+        tags: [...dto.tags],
+        updatedAt: dto.updatedAt,
+    };
+}
+function fromCommonDto(dto) {
+    return {
+        id: dto.versionId,
+        source: 'COMMON',
+        title: dto.title,
+        target: dto.target,
+        path: normalizeModStudioPath(dto.path),
+        content: dto.content,
+        tags: [...dto.tags],
+        updatedAt: dto.updatedAt,
+    };
+}
+function kindFromApi(pairing) {
+    if (pairing === PlayerCodePairingPreference.ServerOnly)
+        return 'SERVER';
+    if (pairing === PlayerCodePairingPreference.ClientOnly)
+        return 'CLIENT';
+    return 'FULL_STACK';
+}
+function fromApiPairing(pairing) {
+    if (pairing === PlayerCodePairingPreference.Paired)
+        return 'REQUIRED';
+    if (pairing === PlayerCodePairingPreference.Independent)
+        return 'OPTIONAL';
+    return 'NONE';
+}
+function toApiPairing(kind, pairing) {
+    if (kind === 'SERVER')
+        return PlayerCodePairingPreference.ServerOnly;
+    if (kind === 'CLIENT')
+        return PlayerCodePairingPreference.ClientOnly;
+    return pairing === 'REQUIRED'
+        ? PlayerCodePairingPreference.Paired
+        : PlayerCodePairingPreference.Independent;
+}
+function toApiFile(file) {
+    return {
+        target: file.target,
+        path: normalizeModStudioPath(file.path),
+        content: file.content,
+    };
+}
+function projectKind(input) {
+    const hasServer = input.files.some((file) => file.target === 'SERVER');
+    const hasClient = input.files.some((file) => file.target === 'CLIENT');
+    if (hasServer && hasClient)
+        return 'FULL_STACK';
+    if (hasServer)
+        return 'SERVER';
+    return 'CLIENT';
+}
+function projectFileDelta(baseline, input) {
+    const previous = new Map(baseline.files.map((file) => [
+        `${file.target}:${normalizeModStudioPath(file.path)}`,
+        file,
+    ]));
+    const current = new Map(input.files.map((file) => [
+        `${file.target}:${normalizeModStudioPath(file.path)}`,
+        file,
+    ]));
+    const upserts = input.files.filter((file) => {
+        const before = previous.get(`${file.target}:${normalizeModStudioPath(file.path)}`);
+        return !before || before.content !== file.content;
+    });
+    const deletes = baseline.files
+        .filter((file) => !current.has(`${file.target}:${normalizeModStudioPath(file.path)}`))
+        .map((file) => ({ target: file.target, path: file.path }));
+    return { upserts, deletes };
+}
+function cloneProject(project) {
+    return {
+        ...project,
+        metadata: { ...project.metadata },
+        files: project.files.map((file) => ({ ...file })),
+        revision: { ...project.revision },
+    };
+}

package/dist/domains/playerCompute.d.ts

@@ -77,7 +77,7 @@ export declare class PlayerComputeAPI {
     /**
      * Fetch a client artifact and decode its bytes to an ArrayBuffer plus the
      * broker inputs (content hash for side-load verification, per-dispatch fuel
-     * budget). Convenience over {@link artifact} for the live-coding client
+     * budget). Convenience over {@link artifact} for the Mod Studio CLIENT
      * deploy loop.
      */
     artifactBytes(variables: PlayerComputeArtifactQueryVariables): Promise<{

package/dist/domains/playerCompute.js

@@ -116,7 +116,7 @@ export class PlayerComputeAPI {
     /**
      * Fetch a client artifact and decode its bytes to an ArrayBuffer plus the
      * broker inputs (content hash for side-load verification, per-dispatch fuel
-     * budget). Convenience over {@link artifact} for the live-coding client
+     * budget). Convenience over {@link artifact} for the Mod Studio CLIENT
      * deploy loop.
      */
     async artifactBytes(variables) {