Spaces:
Sleeping
Sleeping
| import { | |
| compositionDocumentV1Schema, | |
| compositionListResponseSchema, | |
| compositionVersionSchema, | |
| previewArtifactSchema, | |
| type CompositionDocumentV1, | |
| type CompositionEditOperation, | |
| type CompositionListQuery, | |
| type CompositionVersion, | |
| type PreviewArtifact, | |
| } from "@oloka/contracts"; | |
| import { createHmac, timingSafeEqual } from "node:crypto"; | |
| import type { ObjectStorage } from "../storage/object-storage.js"; | |
| import type { | |
| TransactionContext, | |
| TransactionRunner, | |
| } from "../database/database.js"; | |
| import { | |
| AssetRepository, | |
| type AssetRow, | |
| } from "../database/repositories/asset-repository.js"; | |
| import { AuditEventRepository } from "../database/repositories/audit-event-repository.js"; | |
| import { | |
| CompositionRepository, | |
| PreviewArtifactRepository, | |
| parseCompositionDocument, | |
| parseCompositionValidation, | |
| type CompositionVersionRow, | |
| type PreviewArtifactRow, | |
| } from "../database/repositories/composition-repository.js"; | |
| import { IdempotencyRepository } from "../database/repositories/idempotency-repository.js"; | |
| import { ProjectRepository } from "../database/repositories/project-repository.js"; | |
| import { ApplicationError } from "../http/application-error.js"; | |
| import type { AuthenticatedSession } from "../identity/identity-service.js"; | |
| import { | |
| canonicalizeJson, | |
| sha256CanonicalJson, | |
| sha256Hex, | |
| } from "../kernel/canonical-json.js"; | |
| import type { Clock } from "../kernel/clock.js"; | |
| import type { IdGenerator } from "../kernel/id-generator.js"; | |
| import type { QuotaPolicyResolver } from "../quota/quota-policy.js"; | |
| import { materializeCompositionPreview } from "./composition-materializer.js"; | |
| import { | |
| buildRenderContractFingerprint, | |
| collectCompositionAssetReferences, | |
| CSP_PROFILE_VERSION, | |
| HYPERFRAMES_VERSION, | |
| MATERIALIZER_VERSION, | |
| resolveCompositionManifests, | |
| } from "./composition-manifests.js"; | |
| import { | |
| assertPreviewEmbeddedAssetBudgetV1, | |
| MAX_PREVIEW_EMBEDDED_ASSET_BYTES_V1, | |
| } from "./preview-materialization-policy.js"; | |
| const IDEMPOTENCY_TTL_MS = 24 * 60 * 60 * 1000; | |
| const PREVIEW_RETENTION_MS = 7 * 24 * 60 * 60 * 1000; | |
| export interface CompositionServiceOptions { | |
| transactions: TransactionRunner; | |
| storage: ObjectStorage; | |
| applicationKey: Uint8Array; | |
| clock: Clock; | |
| idGenerator: IdGenerator; | |
| quotaPolicyResolver: QuotaPolicyResolver; | |
| } | |
| export class CompositionService { | |
| private readonly compositions = new CompositionRepository(); | |
| private readonly previews = new PreviewArtifactRepository(); | |
| private readonly assets = new AssetRepository(); | |
| private readonly projects = new ProjectRepository(); | |
| private readonly idempotency: IdempotencyRepository; | |
| private readonly audit: AuditEventRepository; | |
| constructor(private readonly options: CompositionServiceOptions) { | |
| this.idempotency = new IdempotencyRepository(options.idGenerator); | |
| this.audit = new AuditEventRepository(options.idGenerator); | |
| } | |
| create( | |
| actor: AuthenticatedSession, | |
| projectId: string, | |
| input: { document: CompositionDocumentV1; expectedProjectVersion: number }, | |
| idempotencyKey: string, | |
| ): { composition: CompositionVersion; replayed: boolean } { | |
| return this.createVersion( | |
| actor, | |
| projectId, | |
| input.document, | |
| null, | |
| input.expectedProjectVersion, | |
| idempotencyKey, | |
| "composition.create", | |
| ); | |
| } | |
| derive( | |
| actor: AuthenticatedSession, | |
| parentVersionId: string, | |
| input: { | |
| edits: CompositionEditOperation[]; | |
| expectedProjectVersion: number; | |
| }, | |
| idempotencyKey: string, | |
| ): { composition: CompositionVersion; replayed: boolean } { | |
| const parent = this.get(actor, parentVersionId); | |
| const candidate = applyCompositionEdits(parent.document, input.edits); | |
| return this.createVersion( | |
| actor, | |
| parent.projectId, | |
| candidate, | |
| parent.id, | |
| input.expectedProjectVersion, | |
| idempotencyKey, | |
| `composition.derive:${parent.id}`, | |
| ); | |
| } | |
| get( | |
| actor: AuthenticatedSession, | |
| compositionVersionId: string, | |
| ): CompositionVersion { | |
| return this.options.transactions.run("read", (context) => { | |
| const row = this.compositions.getOwned( | |
| context, | |
| compositionVersionId, | |
| actor.user.id, | |
| ); | |
| if (row === null) | |
| throw new ApplicationError( | |
| "RESOURCE_NOT_FOUND", | |
| "composition_not_found", | |
| ); | |
| return toPublicComposition(row); | |
| }); | |
| } | |
| current( | |
| actor: AuthenticatedSession, | |
| projectId: string, | |
| ): CompositionVersion | null { | |
| return this.options.transactions.run("read", (context) => { | |
| const project = this.projects.getById(context, projectId); | |
| if ( | |
| project === null || | |
| project.owner_user_id !== actor.user.id || | |
| project.status !== "active" | |
| ) | |
| throw new ApplicationError("RESOURCE_NOT_FOUND", "project_not_found"); | |
| if (project.current_composition_version_id === null) return null; | |
| const row = this.compositions.getById( | |
| context, | |
| project.current_composition_version_id, | |
| ); | |
| if (row === null) | |
| throw new Error("Current composition pointer is corrupt"); | |
| return toPublicComposition(row); | |
| }); | |
| } | |
| list( | |
| actor: AuthenticatedSession, | |
| projectId: string, | |
| query: CompositionListQuery, | |
| ) { | |
| const filterHash = sha256CanonicalJson({ | |
| ownerUserId: actor.user.id, | |
| projectId, | |
| status: query.status ?? null, | |
| }); | |
| const cursor = | |
| query.cursor === undefined | |
| ? undefined | |
| : this.decodeCursor(query.cursor, filterHash); | |
| return this.options.transactions.run("read", (context) => { | |
| const project = this.projects.getById(context, projectId); | |
| if (project === null || project.owner_user_id !== actor.user.id) | |
| throw new ApplicationError("RESOURCE_NOT_FOUND", "project_not_found"); | |
| const rows = this.compositions.listOwned(context, { | |
| projectId, | |
| ownerUserId: actor.user.id, | |
| ...(query.status === undefined ? {} : { status: query.status }), | |
| ...(cursor === undefined ? {} : { cursor }), | |
| limit: query.limit + 1, | |
| }); | |
| const page = rows.slice(0, query.limit); | |
| const last = page.at(-1); | |
| return compositionListResponseSchema.parse({ | |
| compositions: page.map(toPublicComposition), | |
| nextCursor: | |
| rows.length > query.limit && last !== undefined | |
| ? this.encodeCursor( | |
| { createdAt: last.created_at, id: last.id }, | |
| filterHash, | |
| ) | |
| : null, | |
| }); | |
| }); | |
| } | |
| validate( | |
| actor: AuthenticatedSession, | |
| compositionVersionId: string, | |
| idempotencyKey: string, | |
| ) { | |
| const now = this.options.clock.now(); | |
| return this.options.transactions.run("immediate", (context) => { | |
| const row = this.compositions.getOwned( | |
| context, | |
| compositionVersionId, | |
| actor.user.id, | |
| ); | |
| if (row === null) | |
| throw new ApplicationError( | |
| "RESOURCE_NOT_FOUND", | |
| "composition_not_found", | |
| ); | |
| const semanticRequestHashSha256 = sha256CanonicalJson({ | |
| compositionVersionId, | |
| canonicalHashSha256: row.canonical_hash_sha256, | |
| }); | |
| const begin = this.idempotency.begin(context, { | |
| userId: actor.user.id, | |
| operation: "composition.validate", | |
| idempotencyKey, | |
| semanticRequestHashSha256, | |
| createdAt: now, | |
| expiresAt: now + IDEMPOTENCY_TTL_MS, | |
| }); | |
| if (begin.kind === "replay") | |
| return { | |
| validation: begin.response, | |
| replayed: true, | |
| }; | |
| if (begin.kind !== "started" && begin.kind !== "retryable") | |
| throw this.idempotencyError(begin.kind); | |
| const project = this.projects.getById(context, row.project_id); | |
| if (project === null || project.status !== "active") | |
| throw new ApplicationError( | |
| "RESOURCE_STATE_CONFLICT", | |
| "project_not_active", | |
| ); | |
| const document = parseCompositionDocument(row); | |
| if (sha256Hex(canonicalizeJson(document)) !== row.canonical_hash_sha256) | |
| throw new ApplicationError( | |
| "COMPOSITION_INVALID", | |
| "composition_canonical_hash_mismatch", | |
| ); | |
| this.resolveDocument(context, actor, project.id, document); | |
| const validation = { | |
| schemaVersion: 1 as const, | |
| valid: true, | |
| issues: [], | |
| }; | |
| this.audit.append(context, { | |
| actorUserId: actor.user.id, | |
| actorType: actor.user.role === "admin" ? "admin" : "user", | |
| action: "composition.validate", | |
| resourceType: "composition", | |
| resourceId: row.id, | |
| outcome: "success", | |
| metadata: { projectId: row.project_id }, | |
| createdAt: now, | |
| }); | |
| this.idempotency.complete(context, { | |
| recordId: begin.recordId, | |
| responseStatus: 200, | |
| response: validation, | |
| resourceId: row.id, | |
| }); | |
| return { validation, replayed: false }; | |
| }); | |
| } | |
| async requestPreview( | |
| actor: AuthenticatedSession, | |
| compositionVersionId: string, | |
| idempotencyKey: string, | |
| ): Promise<{ preview: PreviewArtifact; replayed: boolean }> { | |
| const input = this.options.transactions.run("read", (context) => { | |
| const row = this.compositions.getOwned( | |
| context, | |
| compositionVersionId, | |
| actor.user.id, | |
| ); | |
| if (row === null) | |
| throw new ApplicationError( | |
| "RESOURCE_NOT_FOUND", | |
| "composition_not_found", | |
| ); | |
| const project = this.projects.getById(context, row.project_id); | |
| if ( | |
| project === null || | |
| project.status !== "active" || | |
| row.status !== "valid" | |
| ) | |
| throw new ApplicationError( | |
| "RESOURCE_STATE_CONFLICT", | |
| "composition_preview_not_allowed", | |
| ); | |
| return this.resolveDocument( | |
| context, | |
| actor, | |
| project.id, | |
| parseCompositionDocument(row), | |
| ); | |
| }); | |
| const semanticHash = sha256CanonicalJson({ compositionVersionId }); | |
| const begin = this.options.transactions.run("immediate", (context) => | |
| this.idempotency.begin(context, { | |
| userId: actor.user.id, | |
| operation: `composition.preview:${compositionVersionId}`, | |
| idempotencyKey, | |
| semanticRequestHashSha256: semanticHash, | |
| createdAt: this.options.clock.now(), | |
| expiresAt: this.options.clock.now() + IDEMPOTENCY_TTL_MS, | |
| }), | |
| ); | |
| if (begin.kind === "replay") | |
| return { | |
| preview: (begin.response as { preview: PreviewArtifact }).preview, | |
| replayed: true, | |
| }; | |
| if (begin.kind !== "started" && begin.kind !== "retryable") | |
| throw this.idempotencyError(begin.kind); | |
| let stagingKey: string | undefined; | |
| let storageKey: string | undefined; | |
| let persisted = false; | |
| let previewStage = "load-assets"; | |
| try { | |
| const assets = await this.loadAssetBytes(input.assets); | |
| previewStage = "materialize"; | |
| const materialized = await materializeCompositionPreview( | |
| input.document, | |
| assets, | |
| ); | |
| const fingerprint = buildRenderContractFingerprint({ | |
| bundleChecksum: materialized.checksumSha256, | |
| compositionSchemaVersion: input.document.schemaVersion, | |
| renderProtocolVersion: input.document.runtimeVersions.renderProtocol, | |
| rendererVersion: input.document.runtimeVersions.renderer, | |
| hyperframesVersion: input.document.runtimeVersions.hyperframes, | |
| dependencyManifestHash: input.hashes.dependencyManifestHash, | |
| assetManifestHash: input.hashes.assetManifestHash, | |
| fontManifestHash: input.hashes.fontManifestHash, | |
| captionManifestHash: input.hashes.captionManifestHash, | |
| }); | |
| const existing = this.options.transactions.run("read", (context) => | |
| this.previews.findIdentity(context, { | |
| compositionVersionId, | |
| fingerprint, | |
| materializerVersion: MATERIALIZER_VERSION, | |
| cspProfileVersion: CSP_PROFILE_VERSION, | |
| }), | |
| ); | |
| if (existing !== null) { | |
| if (existing.status === "ready") | |
| return this.completePreviewReplay(begin.recordId, existing, false); | |
| if (existing.status === "purged") | |
| return await this.rehydratePreview( | |
| begin.recordId, | |
| existing, | |
| materialized.bytes, | |
| materialized.checksumSha256, | |
| ); | |
| throw new ApplicationError( | |
| "RESOURCE_STATE_CONFLICT", | |
| "preview_identity_not_ready", | |
| ); | |
| } | |
| const objectId = this.options.idGenerator.generate(); | |
| const generatedStagingKey = this.options.idGenerator.generate(); | |
| const generatedStorageKey = `v1/${objectId.slice(0, 2)}/${objectId}`; | |
| stagingKey = generatedStagingKey; | |
| storageKey = generatedStorageKey; | |
| previewStage = "stage"; | |
| await this.options.storage.stage(generatedStagingKey); | |
| await this.options.storage.appendAtOffset( | |
| generatedStagingKey, | |
| 0, | |
| materialized.bytes, | |
| ); | |
| previewStage = "hash-staging"; | |
| if ( | |
| (await this.options.storage.createStagingHash(generatedStagingKey)) !== | |
| materialized.checksumSha256 | |
| ) | |
| throw new ApplicationError( | |
| "CHECKSUM_MISMATCH", | |
| "preview_staging_checksum_mismatch", | |
| ); | |
| previewStage = "finalize"; | |
| await this.options.storage.finalize( | |
| generatedStagingKey, | |
| generatedStorageKey, | |
| ); | |
| previewStage = "persist"; | |
| const now = this.options.clock.now(); | |
| let row: PreviewArtifactRow; | |
| try { | |
| row = this.options.transactions.run("immediate", (context) => { | |
| const inserted = this.previews.insert(context, { | |
| id: this.options.idGenerator.generate(), | |
| composition_version_id: compositionVersionId, | |
| render_contract_fingerprint_sha256: fingerprint, | |
| materializer_version: MATERIALIZER_VERSION, | |
| hyperframes_version: HYPERFRAMES_VERSION, | |
| csp_profile_version: CSP_PROFILE_VERSION, | |
| storage_key: generatedStorageKey, | |
| byte_checksum_sha256: materialized.checksumSha256, | |
| status: "ready", | |
| created_at: now, | |
| purge_after: now + PREVIEW_RETENTION_MS, | |
| }); | |
| this.audit.append(context, { | |
| actorUserId: actor.user.id, | |
| actorType: actor.user.role === "admin" ? "admin" : "user", | |
| action: "preview.materialized", | |
| resourceType: "preview", | |
| resourceId: inserted.id, | |
| outcome: "success", | |
| metadata: { | |
| compositionVersionId, | |
| materializerVersion: MATERIALIZER_VERSION, | |
| }, | |
| createdAt: now, | |
| }); | |
| return inserted; | |
| }); | |
| persisted = true; | |
| } catch (error) { | |
| const winner = this.options.transactions.run("read", (context) => | |
| this.previews.findIdentity(context, { | |
| compositionVersionId, | |
| fingerprint, | |
| materializerVersion: MATERIALIZER_VERSION, | |
| cspProfileVersion: CSP_PROFILE_VERSION, | |
| }), | |
| ); | |
| if (winner === null) throw error; | |
| await this.options.storage.delete("durable", generatedStorageKey); | |
| storageKey = undefined; | |
| row = winner; | |
| } | |
| previewStage = "complete"; | |
| return this.completePreviewReplay(begin.recordId, row, false); | |
| } catch (error) { | |
| if (typeof error === "object" && error !== null) { | |
| Object.defineProperty(error, "previewStage", { | |
| value: previewStage, | |
| enumerable: false, | |
| }); | |
| } | |
| await Promise.allSettled([ | |
| ...(stagingKey === undefined | |
| ? [] | |
| : [this.options.storage.delete("staging", stagingKey)]), | |
| ...(storageKey === undefined || persisted | |
| ? [] | |
| : [this.options.storage.delete("durable", storageKey)]), | |
| ]); | |
| this.options.transactions.run("immediate", (context) => | |
| this.idempotency.markRetryableFailure(context, begin.recordId), | |
| ); | |
| throw error; | |
| } | |
| } | |
| previewDescriptor( | |
| actor: AuthenticatedSession, | |
| previewArtifactId: string, | |
| ): { preview: PreviewArtifact; storageKey: string } { | |
| return this.options.transactions.run("read", (context) => { | |
| const row = this.previews.getOwned( | |
| context, | |
| previewArtifactId, | |
| actor.user.id, | |
| ); | |
| if (row === null || row.status !== "ready") | |
| throw new ApplicationError("RESOURCE_NOT_FOUND", "preview_not_found"); | |
| return { preview: toPublicPreview(row), storageKey: row.storage_key }; | |
| }); | |
| } | |
| private createVersion( | |
| actor: AuthenticatedSession, | |
| projectId: string, | |
| rawDocument: CompositionDocumentV1, | |
| parentVersionId: string | null, | |
| expectedProjectVersion: number, | |
| idempotencyKey: string, | |
| operation: string, | |
| ): { composition: CompositionVersion; replayed: boolean } { | |
| const parsed = compositionDocumentV1Schema.safeParse(rawDocument); | |
| if (!parsed.success) | |
| throw new ApplicationError( | |
| "COMPOSITION_INVALID", | |
| "composition_schema_invalid", | |
| ); | |
| const now = this.options.clock.now(); | |
| return this.options.transactions.run("immediate", (context) => { | |
| const project = this.projects.getById(context, projectId); | |
| if (project === null || project.owner_user_id !== actor.user.id) | |
| throw new ApplicationError("RESOURCE_NOT_FOUND", "project_not_found"); | |
| const begin = this.idempotency.begin(context, { | |
| userId: actor.user.id, | |
| operation, | |
| idempotencyKey, | |
| semanticRequestHashSha256: sha256CanonicalJson({ | |
| projectId, | |
| parentVersionId, | |
| expectedProjectVersion, | |
| document: parsed.data, | |
| }), | |
| createdAt: now, | |
| expiresAt: now + IDEMPOTENCY_TTL_MS, | |
| }); | |
| if (begin.kind === "replay") | |
| return { | |
| composition: (begin.response as { composition: CompositionVersion }) | |
| .composition, | |
| replayed: true, | |
| }; | |
| if (begin.kind !== "started" && begin.kind !== "retryable") | |
| throw this.idempotencyError(begin.kind); | |
| if (project.status !== "active") | |
| throw new ApplicationError( | |
| "RESOURCE_STATE_CONFLICT", | |
| "project_not_active", | |
| ); | |
| if (project.version !== expectedProjectVersion) | |
| throw new ApplicationError("VERSION_CONFLICT", "project_version_stale"); | |
| if ( | |
| parentVersionId !== null && | |
| project.current_composition_version_id !== parentVersionId | |
| ) | |
| throw new ApplicationError( | |
| "VERSION_CONFLICT", | |
| "composition_parent_stale", | |
| ); | |
| const resolution = this.resolveDocument( | |
| context, | |
| actor, | |
| projectId, | |
| parsed.data, | |
| ); | |
| const canonicalHashSha256 = sha256Hex( | |
| canonicalizeJson(resolution.document), | |
| ); | |
| const validation = { schemaVersion: 1 as const, valid: true, issues: [] }; | |
| const row = this.compositions.insert(context, { | |
| id: this.options.idGenerator.generate(), | |
| projectId, | |
| createdByUserId: actor.user.id, | |
| versionNumber: this.compositions.nextVersionNumber(context, projectId), | |
| ...(parentVersionId === null ? {} : { parentVersionId }), | |
| document: resolution.document, | |
| canonicalHashSha256, | |
| status: "valid", | |
| validation, | |
| createdAt: now, | |
| references: collectCompositionAssetReferences(resolution.document), | |
| }); | |
| if ( | |
| !this.compositions.advanceProjectPointer(context, { | |
| projectId, | |
| ownerUserId: actor.user.id, | |
| compositionVersionId: row.id, | |
| expectedProjectVersion, | |
| now, | |
| }) | |
| ) | |
| throw new ApplicationError("VERSION_CONFLICT", "project_version_stale"); | |
| const composition = toPublicComposition(row); | |
| this.audit.append(context, { | |
| actorUserId: actor.user.id, | |
| actorType: actor.user.role === "admin" ? "admin" : "user", | |
| action: | |
| parentVersionId === null | |
| ? "composition.create" | |
| : "composition.derive", | |
| resourceType: "composition", | |
| resourceId: row.id, | |
| outcome: "success", | |
| metadata: { projectId, versionNumber: row.version_number }, | |
| createdAt: now, | |
| }); | |
| const response = { composition }; | |
| this.idempotency.complete(context, { | |
| recordId: begin.recordId, | |
| responseStatus: 201, | |
| response, | |
| resourceId: row.id, | |
| }); | |
| return { ...response, replayed: false }; | |
| }); | |
| } | |
| private resolveDocument( | |
| context: TransactionContext, | |
| actor: AuthenticatedSession, | |
| projectId: string, | |
| document: CompositionDocumentV1, | |
| ) { | |
| const policy = this.options.quotaPolicyResolver.resolve({ | |
| userId: actor.user.id, | |
| projectId, | |
| at: this.options.clock.now(), | |
| }); | |
| if (document.durationMs > policy.maxVideoDurationSeconds * 1000) | |
| throw new ApplicationError( | |
| "QUOTA_EXCEEDED", | |
| "composition_duration_quota_exceeded", | |
| ); | |
| const references = collectCompositionAssetReferences(document); | |
| const rows: AssetRow[] = []; | |
| for (const reference of references) { | |
| const row = this.assets.getAsset(context, reference.assetId); | |
| if ( | |
| row === null || | |
| row.owner_user_id !== actor.user.id || | |
| row.project_id !== projectId | |
| ) | |
| throw new ApplicationError( | |
| "ASSET_UNAVAILABLE", | |
| "composition_asset_unavailable", | |
| ); | |
| rows.push(row); | |
| } | |
| return resolveCompositionManifests(document, rows); | |
| } | |
| private async loadAssetBytes( | |
| assets: ReturnType<typeof resolveCompositionManifests>["assets"], | |
| ) { | |
| const total = assets.reduce((sum, asset) => sum + asset.byteSize, 0); | |
| assertPreviewEmbeddedAssetBudgetV1(total); | |
| return Promise.all( | |
| assets.map(async (asset) => { | |
| const stream = await this.options.storage.openRange( | |
| asset.storageKey, | |
| 0, | |
| asset.byteSize - 1, | |
| ); | |
| const chunks: Buffer[] = []; | |
| let length = 0; | |
| for await (const chunk of stream as AsyncIterable< | |
| Buffer | Uint8Array | |
| >) { | |
| const bytes = Buffer.from(chunk); | |
| length += bytes.length; | |
| if (length > MAX_PREVIEW_EMBEDDED_ASSET_BYTES_V1) | |
| throw new ApplicationError( | |
| "PAYLOAD_TOO_LARGE", | |
| "preview_embedded_media_limit", | |
| ); | |
| chunks.push(bytes); | |
| } | |
| const bytes = Buffer.concat(chunks); | |
| if ( | |
| bytes.length !== asset.byteSize || | |
| sha256Hex(bytes) !== asset.checksumSha256 | |
| ) | |
| throw new ApplicationError( | |
| "CHECKSUM_MISMATCH", | |
| "preview_asset_checksum_mismatch", | |
| ); | |
| return { id: asset.id, mime: asset.mime, bytes }; | |
| }), | |
| ); | |
| } | |
| private completePreviewReplay( | |
| recordId: string, | |
| row: PreviewArtifactRow, | |
| replayed: boolean, | |
| ) { | |
| const preview = toPublicPreview(row); | |
| this.options.transactions.run("immediate", (context) => | |
| this.idempotency.complete(context, { | |
| recordId, | |
| responseStatus: 200, | |
| response: { preview }, | |
| resourceId: row.id, | |
| }), | |
| ); | |
| return { preview, replayed }; | |
| } | |
| private async rehydratePreview( | |
| recordId: string, | |
| row: PreviewArtifactRow, | |
| bytes: Uint8Array, | |
| checksumSha256: string, | |
| ) { | |
| if (checksumSha256 !== row.byte_checksum_sha256) { | |
| this.options.transactions.run("immediate", (context) => | |
| this.previews.quarantine(context, row.id), | |
| ); | |
| throw new ApplicationError( | |
| "CHECKSUM_MISMATCH", | |
| "preview_rehydration_checksum_mismatch", | |
| ); | |
| } | |
| const stagingKey = this.options.idGenerator.generate(); | |
| try { | |
| await this.options.storage.stage(stagingKey); | |
| await this.options.storage.appendAtOffset(stagingKey, 0, bytes); | |
| if ( | |
| (await this.options.storage.createStagingHash(stagingKey)) !== | |
| row.byte_checksum_sha256 | |
| ) | |
| throw new ApplicationError( | |
| "CHECKSUM_MISMATCH", | |
| "preview_rehydration_staging_checksum_mismatch", | |
| ); | |
| try { | |
| await this.options.storage.finalize(stagingKey, row.storage_key); | |
| } catch (error) { | |
| await this.options.storage.delete("staging", stagingKey); | |
| if ( | |
| (await this.options.storage | |
| .createHash(row.storage_key) | |
| .catch(() => null)) !== row.byte_checksum_sha256 | |
| ) | |
| throw error; | |
| } | |
| const now = this.options.clock.now(); | |
| const current = this.options.transactions.run("immediate", (context) => { | |
| this.previews.markRehydrated(context, { | |
| id: row.id, | |
| purgeAfter: now + PREVIEW_RETENTION_MS, | |
| }); | |
| const refreshed = this.previews.getById(context, row.id); | |
| if (refreshed === null || refreshed.status !== "ready") | |
| throw new Error("Preview rehydration state conflict"); | |
| return refreshed; | |
| }); | |
| return this.completePreviewReplay(recordId, current, false); | |
| } catch (error) { | |
| await this.options.storage | |
| .delete("staging", stagingKey) | |
| .catch(() => undefined); | |
| throw error; | |
| } | |
| } | |
| private idempotencyError(kind: "conflict" | "in_progress"): ApplicationError { | |
| return new ApplicationError( | |
| kind === "conflict" ? "IDEMPOTENCY_CONFLICT" : "RESOURCE_STATE_CONFLICT", | |
| kind === "conflict" | |
| ? "composition_idempotency_conflict" | |
| : "composition_idempotency_in_progress", | |
| ); | |
| } | |
| private encodeCursor( | |
| sort: { createdAt: number; id: string }, | |
| filterHash: string, | |
| ): string { | |
| const payload = Buffer.from( | |
| JSON.stringify({ v: 1, sort, filterHash }), | |
| "utf8", | |
| ).toString("base64url"); | |
| const signature = createHmac("sha256", this.options.applicationKey) | |
| .update(payload) | |
| .digest("base64url"); | |
| return `${payload}.${signature}`; | |
| } | |
| private decodeCursor( | |
| cursor: string, | |
| filterHash: string, | |
| ): { createdAt: number; id: string } { | |
| try { | |
| const [payload, signature, extra] = cursor.split("."); | |
| if ( | |
| payload === undefined || | |
| signature === undefined || | |
| extra !== undefined | |
| ) | |
| throw new Error(); | |
| const expected = createHmac("sha256", this.options.applicationKey) | |
| .update(payload) | |
| .digest(); | |
| const actual = Buffer.from(signature, "base64url"); | |
| if ( | |
| expected.length !== actual.length || | |
| !timingSafeEqual(expected, actual) | |
| ) | |
| throw new Error(); | |
| const decoded = JSON.parse( | |
| Buffer.from(payload, "base64url").toString("utf8"), | |
| ) as { | |
| v?: unknown; | |
| sort?: { createdAt?: unknown; id?: unknown }; | |
| filterHash?: unknown; | |
| }; | |
| if ( | |
| decoded.v !== 1 || | |
| !Number.isSafeInteger(decoded.sort?.createdAt) || | |
| typeof decoded.sort?.id !== "string" || | |
| decoded.filterHash !== filterHash | |
| ) | |
| throw new Error(); | |
| return { | |
| createdAt: decoded.sort.createdAt as number, | |
| id: decoded.sort.id, | |
| }; | |
| } catch { | |
| throw new ApplicationError( | |
| "INVALID_CURSOR", | |
| "composition_cursor_invalid", | |
| ); | |
| } | |
| } | |
| } | |
| function toPublicComposition(row: CompositionVersionRow): CompositionVersion { | |
| return compositionVersionSchema.parse({ | |
| id: row.id, | |
| projectId: row.project_id, | |
| versionNumber: row.version_number, | |
| parentVersionId: row.parent_version_id, | |
| document: parseCompositionDocument(row), | |
| canonicalHashSha256: row.canonical_hash_sha256, | |
| status: row.status, | |
| validation: parseCompositionValidation(row), | |
| createdAt: new Date(row.created_at).toISOString(), | |
| }); | |
| } | |
| function toPublicPreview(row: PreviewArtifactRow): PreviewArtifact { | |
| return previewArtifactSchema.parse({ | |
| id: row.id, | |
| compositionVersionId: row.composition_version_id, | |
| renderContractFingerprintSha256: row.render_contract_fingerprint_sha256, | |
| materializerVersion: row.materializer_version, | |
| hyperframesVersion: row.hyperframes_version, | |
| cspProfileVersion: row.csp_profile_version, | |
| byteChecksumSha256: row.byte_checksum_sha256, | |
| status: row.status, | |
| createdAt: new Date(row.created_at).toISOString(), | |
| contentUrl: `/api/v1/previews/${row.id}/content`, | |
| }); | |
| } | |
| function applyCompositionEdits( | |
| source: CompositionDocumentV1, | |
| edits: CompositionEditOperation[], | |
| ): CompositionDocumentV1 { | |
| const document = structuredClone(source); | |
| for (const edit of edits) { | |
| if (edit.type === "aspectRatio") { | |
| const presets = { | |
| "16:9": [1920, 1080], | |
| "9:16": [1080, 1920], | |
| "1:1": [1080, 1080], | |
| "4:5": [1080, 1350], | |
| } as const; | |
| document.aspectRatio = edit.aspectRatio; | |
| [document.width, document.height] = presets[edit.aspectRatio]; | |
| continue; | |
| } | |
| if (edit.type === "voice") { | |
| document.voiceConfig = edit.voiceConfig; | |
| continue; | |
| } | |
| if (edit.type === "caption") { | |
| document.captionConfig = edit.captionConfig; | |
| continue; | |
| } | |
| if (edit.type === "bgm") { | |
| document.bgmConfig = edit.bgmConfig; | |
| continue; | |
| } | |
| const scene = document.scenes.find( | |
| (candidate) => candidate.id === edit.sceneId, | |
| ); | |
| if (scene === undefined) | |
| throw new ApplicationError( | |
| "COMPOSITION_INVALID", | |
| "composition_scene_missing", | |
| ); | |
| if (edit.type === "sceneText") scene.text = edit.text; | |
| if (edit.type === "sceneDuration") scene.durationMs = edit.durationMs; | |
| if (edit.type === "sceneAsset") scene.assetReferences = edit.references; | |
| if (edit.type === "sceneStyle") scene.style = edit.style; | |
| if (edit.type === "sceneOrder") { | |
| const current = document.scenes.indexOf(scene); | |
| document.scenes.splice(current, 1); | |
| document.scenes.splice( | |
| Math.min(edit.order, document.scenes.length), | |
| 0, | |
| scene, | |
| ); | |
| } | |
| } | |
| let startMs = 0; | |
| document.scenes.forEach((scene, order) => { | |
| scene.order = order; | |
| scene.startMs = startMs; | |
| startMs += scene.durationMs; | |
| }); | |
| document.durationMs = startMs; | |
| return compositionDocumentV1Schema.parse(document); | |
| } | |