@mevdragon/vidfarm-devcli 0.2.12 → 0.2.14

package/dist/src/services/serverless-records.js

@@ -0,0 +1,1088 @@
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DeleteCommand, DynamoDBDocumentClient, GetCommand, PutCommand, QueryCommand, ScanCommand } from "@aws-sdk/lib-dynamodb";
+import { config } from "../config.js";
+import { devLog } from "../lib/dev-log.js";
+import { displayNameFromEmail } from "../lib/display-name.js";
+import { createId, createIdV7 } from "../lib/ids.js";
+import { nowIso } from "../lib/time.js";
+import { ServerlessAuthService } from "./serverless-auth.js";
+const dynamodb = DynamoDBDocumentClient.from(new DynamoDBClient({}), {
+    marshallOptions: {
+        removeUndefinedValues: true
+    }
+});
+const METHOD_COLLECTIONS = {
+    archiveReadyPost: "ready_post",
+    createCompositionFork: "composition_fork",
+    deleteCompositionFork: "composition_fork",
+    getCompositionFork: "composition_fork",
+    listCompositionForksForCustomer: "composition_fork",
+    updateCompositionFork: "composition_fork",
+    createEmailChannel: "email_channel",
+    createPostSchedule: "post_schedule",
+    createReadyPost: "ready_post",
+    createTemplateRelease: "template_release",
+    createTemplateSource: "template_source",
+    createUserAttachment: "user_attachment",
+    createUserFileFolder: "user_file_folder",
+    createUserTemporaryFile: "user_temporary_file",
+    deleteEmailChannel: "email_channel",
+    deleteReadyPost: "ready_post",
+    deleteUserAttachment: "user_attachment",
+    deleteUserFileFolder: "user_file_folder",
+    deleteUserTemporaryFile: "user_temporary_file",
+    getEmailChannel: "email_channel",
+    getEmailChannelByEmail: "email_channel",
+    getPostSchedule: "post_schedule",
+    getReadyPost: "ready_post",
+    getTemplateRelease: "template_release",
+    getTemplateSource: "template_source",
+    getTemplateSourceByLocation: "template_source",
+    getTemplateSourceBySlugId: "template_source",
+    getTemplateSourceByTemplateId: "template_source",
+    getUserAttachment: "user_attachment",
+    getUserTemporaryFile: "user_temporary_file",
+    listEmailChannels: "email_channel",
+    listPostSchedulesForCalendar: "post_schedule",
+    listPostSchedulesForPost: "post_schedule",
+    listReadyPosts: "ready_post",
+    listTemplateReleases: "template_release",
+    listTemplateSources: "template_source",
+    listUserAttachments: "user_attachment",
+    listUserFileFolders: "user_file_folder",
+    listUserTemporaryFiles: "user_temporary_file",
+    markPostScheduleCancelled: "post_schedule",
+    markPostScheduleFailed: "post_schedule",
+    moveUserAttachmentFolder: "user_attachment",
+    moveUserFileFolder: "user_file_folder",
+    moveUserTemporaryFolder: "user_temporary_file",
+    queueWebhookDelivery: "webhook_delivery",
+    setReadyPostZip: "ready_post",
+    updateEmailChannel: "email_channel",
+    updateEmailChannelAvatar: "email_channel",
+    updateEmailChannelVerification: "email_channel",
+    updatePostScheduleProvider: "post_schedule",
+    updateTemplateSource: "template_source",
+    upsertExternalPostSchedule: "post_schedule"
+};
+class ServerlessRecordsServiceImpl {
+    auth = new ServerlessAuthService();
+    async getCustomerById(customerId) {
+        return this.auth.getCustomerById(customerId);
+    }
+    async getCustomerByEmail(email) {
+        return this.auth.getCustomerByEmailPublic(email);
+    }
+    async upsertCustomer(input) {
+        return this.auth.upsertCustomer(input);
+    }
+    async insertApiKey(input) {
+        return this.auth.insertApiKey(input);
+    }
+    async getFirstPaidCustomer() {
+        const response = await dynamodb.send(new ScanCommand({
+            TableName: requireMainTableName(),
+            FilterExpression: "entity_type = :type AND is_paid_plan = :paid",
+            ExpressionAttributeValues: {
+                ":type": "Customer",
+                ":paid": true
+            },
+            Limit: 1
+        }));
+        return response.Items?.[0] ? itemToCustomer(response.Items[0]) : null;
+    }
+    async setCustomerAccessByEmail(input) {
+        const normalizedEmail = input.email.trim().toLowerCase();
+        const existing = await this.auth.getCustomerByEmailPublic(normalizedEmail);
+        return this.auth.upsertCustomer({
+            id: existing?.id ?? createId("cus"),
+            email: normalizedEmail,
+            name: input.name?.trim() || existing?.name || displayNameFromEmail(normalizedEmail),
+            defaultWebhookUrl: existing?.defaultWebhookUrl ?? null,
+            isDeveloper: input.isDeveloper ?? existing?.isDeveloper ?? false,
+            isAgency: input.isAgency ?? existing?.isAgency ?? false,
+            isPaidPlan: input.isPaidPlan ?? existing?.isPaidPlan ?? false,
+            planTier: input.planTier ?? existing?.planTier ?? "client"
+        });
+    }
+    async updateCustomerPaidPlan(customerId, isPaidPlan, planTier = "client") {
+        const existing = await this.auth.getCustomerById(customerId);
+        if (!existing)
+            return null;
+        return this.auth.upsertCustomer({ ...existing, isPaidPlan, planTier });
+    }
+    async updateCustomerAgencyStatus(customerId, isAgency) {
+        const existing = await this.auth.getCustomerById(customerId);
+        if (!existing)
+            return null;
+        return this.auth.upsertCustomer({ ...existing, isAgency, planTier: isAgency ? "agency" : existing.planTier });
+    }
+    async updateCustomerProfile(input) {
+        const existing = await this.auth.getCustomerById(input.customerId);
+        if (!existing)
+            return null;
+        return this.auth.upsertCustomer({
+            ...existing,
+            name: input.name === undefined ? existing.name : input.name,
+            about: input.about === undefined ? existing.about : input.about,
+            defaultWebhookUrl: input.defaultWebhookUrl === undefined ? existing.defaultWebhookUrl : input.defaultWebhookUrl,
+            groupchatUrl: input.groupchatUrl === undefined ? existing.groupchatUrl : input.groupchatUrl,
+            flockposterApiKey: input.flockposterApiKey === undefined ? existing.flockposterApiKey : input.flockposterApiKey
+        });
+    }
+    async getLatestApiKeyForCustomer(customerId) {
+        const response = await dynamodb.send(new QueryCommand({
+            TableName: requireMainTableName(),
+            IndexName: "gsi1",
+            KeyConditionExpression: "gsi1pk = :pk",
+            FilterExpression: "#status = :status",
+            ExpressionAttributeNames: {
+                "#status": "status"
+            },
+            ExpressionAttributeValues: {
+                ":pk": `CUSTOMER#${customerId}#APIKEYS`,
+                ":status": "active"
+            },
+            ScanIndexForward: false,
+            Limit: 1
+        }));
+        return response.Items?.[0] ?? null;
+    }
+    async hasCustomerCreditGrant(customerId, grantType) {
+        return Boolean(await this.getById("credit_grant", `${customerId}:${grantType}`));
+    }
+    async insertCustomerCreditGrant(input) {
+        await this.putRecord("credit_grant", {
+            ...input,
+            id: `${input.customerId}:${input.grantType}`,
+            customerId: input.customerId
+        });
+    }
+    async grantAgencyClientAccess(input) {
+        return this.putRecord("agency_access", {
+            id: `${input.agencyCustomerId}:${input.clientCustomerId}`,
+            customerId: input.agencyCustomerId,
+            agencyCustomerId: input.agencyCustomerId,
+            clientCustomerId: input.clientCustomerId
+        });
+    }
+    async revokeAgencyClientAccess(input) {
+        const record = await this.getById("agency_access", `${input.agencyCustomerId}:${input.clientCustomerId}`);
+        await this.deleteById("agency_access", `${input.agencyCustomerId}:${input.clientCustomerId}`);
+        return record;
+    }
+    async listAgencyClients(input) {
+        const links = await this.listByCustomer("agency_access", input.agencyCustomerId);
+        const clients = [];
+        for (const link of links) {
+            const clientId = String(link.clientCustomerId ?? "");
+            const customer = clientId ? await this.auth.getCustomerById(clientId) : null;
+            if (customer)
+                clients.push({ ...link, customer });
+        }
+        return clients;
+    }
+    async getAgencyClient(agencyCustomerId, clientCustomerId) {
+        return this.getById("agency_access", `${agencyCustomerId}:${clientCustomerId}`);
+    }
+    async createCompositionFork(input) {
+        const timestamp = nowIso();
+        return this.putRecord("composition_fork", {
+            id: input.id ?? createIdV7("fork"),
+            customerId: input.customerId,
+            sourceSlugId: input.sourceSlugId,
+            sourceVideoId: input.sourceVideoId ?? null,
+            parentForkId: input.parentForkId ?? null,
+            parentVersion: input.parentVersion ?? null,
+            title: input.title ?? null,
+            visibility: input.visibility ?? "private",
+            latestVersion: 0,
+            currentRenderJobId: null,
+            deletedAt: null,
+            createdAt: timestamp,
+            updatedAt: timestamp
+        });
+    }
+    async getCompositionFork(forkId) {
+        const fork = await this.getById("composition_fork", forkId);
+        if (!fork)
+            return null;
+        return {
+            ...fork,
+            sourceVideoId: fork.sourceVideoId ?? null,
+            parentForkId: fork.parentForkId ?? null,
+            parentVersion: fork.parentVersion ?? null,
+            visibility: fork.visibility ?? "private",
+            latestVersion: fork.latestVersion ?? 0
+        };
+    }
+    async listCompositionForksForCustomer(customerId) {
+        return this.listByCustomer("composition_fork", customerId);
+    }
+    async listPublicCompositionForks() {
+        return (await this.scanCollection("composition_fork"))
+            .filter((fork) => !fork.deletedAt && fork.visibility === "public");
+    }
+    async updateCompositionFork(input) {
+        const existing = await this.getCompositionFork(input.forkId);
+        if (!existing)
+            return null;
+        return this.putRecord("composition_fork", {
+            ...existing,
+            ...input.patch,
+            id: existing.id,
+            customerId: existing.customerId,
+            updatedAt: nowIso()
+        });
+    }
+    async deleteCompositionFork(input) {
+        const existing = await this.getCompositionFork(input.forkId);
+        if (!existing || existing.customerId !== input.customerId)
+            return null;
+        return this.putRecord("composition_fork", {
+            ...existing,
+            deletedAt: nowIso(),
+            updatedAt: nowIso()
+        });
+    }
+    async grantForkPermission(input) {
+        const existing = (await this.listForkPermissions(input.forkId))
+            .find((perm) => perm.granteeType === input.granteeType && perm.granteeId === input.granteeId);
+        const timestamp = nowIso();
+        const id = existing?.id ?? createId("perm");
+        return this.putRecord("fork_permission", {
+            id,
+            forkId: input.forkId,
+            ownerCustomerId: input.ownerCustomerId,
+            granteeType: input.granteeType,
+            granteeId: input.granteeId,
+            role: input.role,
+            grantedBy: input.grantedBy,
+            expiresAt: input.expiresAt ?? null,
+            createdAt: existing?.createdAt ?? timestamp,
+            updatedAt: timestamp
+        }, { partitionKey: forkPartitionPk("fork_permission", input.forkId) });
+    }
+    async listForkPermissions(forkId) {
+        return this.listByPartition("fork_permission", forkPartitionPk("fork_permission", forkId));
+    }
+    async listForkPermissionsForGrantee(customerId) {
+        return (await this.scanCollection("fork_permission"))
+            .filter((perm) => perm.granteeType === "customer" && perm.granteeId === customerId);
+    }
+    async deleteForkPermission(input) {
+        const existing = (await this.listForkPermissions(input.forkId)).find((perm) => perm.id === input.permissionId);
+        if (!existing)
+            return null;
+        await this.deleteById("fork_permission", input.permissionId);
+        return existing;
+    }
+    async createForkShareLink(input) {
+        const timestamp = nowIso();
+        return this.putRecord("fork_share_link", {
+            id: input.token,
+            forkId: input.forkId,
+            ownerCustomerId: input.ownerCustomerId,
+            token: input.token,
+            role: input.role,
+            createdBy: input.createdBy,
+            expiresAt: input.expiresAt ?? null,
+            revokedAt: null,
+            createdAt: timestamp,
+            updatedAt: timestamp
+        }, { partitionKey: forkPartitionPk("fork_share_link", input.forkId) });
+    }
+    async getForkShareLinkByToken(token) {
+        return this.getById("fork_share_link", token);
+    }
+    async listForkShareLinks(forkId) {
+        return this.listByPartition("fork_share_link", forkPartitionPk("fork_share_link", forkId));
+    }
+    async revokeForkShareLink(input) {
+        const existing = await this.getForkShareLinkByToken(input.token);
+        if (!existing || existing.forkId !== input.forkId)
+            return null;
+        return this.putRecord("fork_share_link", {
+            ...existing,
+            revokedAt: nowIso(),
+            updatedAt: nowIso()
+        }, { partitionKey: forkPartitionPk("fork_share_link", input.forkId) });
+    }
+    async createForkVersion(input) {
+        const timestamp = nowIso();
+        return this.putRecord("fork_version", {
+            id: `${input.forkId}:${input.version}`,
+            forkId: input.forkId,
+            ownerCustomerId: input.ownerCustomerId,
+            version: input.version,
+            reason: input.reason,
+            message: input.message ?? null,
+            createdBy: input.createdBy,
+            storagePrefix: input.storagePrefix,
+            renderJobId: input.renderJobId ?? null,
+            createdAt: timestamp,
+            updatedAt: timestamp
+        }, { partitionKey: forkPartitionPk("fork_version", input.forkId) });
+    }
+    async getForkVersion(forkId, version) {
+        return this.getById("fork_version", `${forkId}:${version}`);
+    }
+    async listForkVersions(input) {
+        const limit = Math.max(1, Math.min(input.limit ?? 25, 200));
+        let ExclusiveStartKey = decodeDynamoCursor(input.cursor);
+        const items = [];
+        do {
+            const response = await dynamodb.send(new QueryCommand({
+                TableName: requireMainTableName(),
+                IndexName: "gsi1",
+                KeyConditionExpression: "gsi1pk = :pk",
+                ExpressionAttributeValues: {
+                    ":pk": forkPartitionPk("fork_version", input.forkId)
+                },
+                ScanIndexForward: false,
+                Limit: Math.max(1, limit - items.length),
+                ExclusiveStartKey
+            }));
+            items.push(...(response.Items ?? []).map((item) => item.data));
+            ExclusiveStartKey = response.LastEvaluatedKey;
+        } while (ExclusiveStartKey && items.length < limit);
+        return { items, nextCursor: encodeDynamoCursor(ExclusiveStartKey) };
+    }
+    async createSubmittedVideo(input) {
+        const timestamp = nowIso();
+        return this.putRecord("submitted_video", {
+            id: input.id ?? createId("video"),
+            customerId: input.customerId,
+            sourceUrl: input.sourceUrl,
+            sourceHost: input.sourceHost,
+            status: "downloading",
+            downloadJobId: input.downloadJobId ?? null,
+            videoStorageKey: null,
+            videoUrl: null,
+            thumbnailUrl: null,
+            title: null,
+            durationSeconds: null,
+            defaultForkId: null,
+            errorMessage: null,
+            createdAt: timestamp,
+            updatedAt: timestamp
+        });
+    }
+    async getSubmittedVideo(videoId) {
+        return this.getById("submitted_video", videoId);
+    }
+    async findSubmittedVideoByUrl(sourceUrl) {
+        return this.findByScan("submitted_video", (item) => item.sourceUrl === sourceUrl);
+    }
+    async updateSubmittedVideo(input) {
+        const existing = await this.getSubmittedVideo(input.videoId);
+        if (!existing)
+            return null;
+        return this.putRecord("submitted_video", {
+            ...existing,
+            ...input.patch,
+            id: existing.id,
+            customerId: existing.customerId,
+            updatedAt: nowIso()
+        });
+    }
+    async listSubmittedVideosForCustomer(customerId) {
+        return this.listByCustomer("submitted_video", customerId);
+    }
+    async listSubmittedVideosFeed(input = {}) {
+        const limit = Math.max(1, Math.min(input.limit ?? 50, 200));
+        const all = (await this.scanCollection("submitted_video"))
+            .filter((video) => video.status === "ready");
+        return all
+            .sort((a, b) => String(b.createdAt ?? "").localeCompare(String(a.createdAt ?? "")))
+            .slice(0, limit);
+    }
+    async createReadyPost(input) {
+        const timestamp = nowIso();
+        return this.putRecord("ready_post", {
+            id: input.id ?? createId("post"),
+            customerId: input.customerId,
+            status: input.status ?? "ready",
+            source: input.source ?? "hyperframes",
+            compositionId: input.compositionId ?? null,
+            tracer: input.tracer ?? null,
+            title: input.title ?? null,
+            caption: input.caption ?? "",
+            pinnedComment: input.pinnedComment ?? null,
+            mediaAssets: input.mediaAssets ?? [],
+            sharePasswordHash: input.sharePasswordHash ?? null,
+            zipStorageKey: input.zipStorageKey ?? null,
+            zipPublicUrl: input.zipPublicUrl ?? null,
+            archivedAt: input.archivedAt ?? null,
+            deletedAt: input.deletedAt ?? null,
+            createdAt: input.createdAt ?? timestamp,
+            updatedAt: timestamp
+        });
+    }
+    async getReadyPost(postId) {
+        return this.getById("ready_post", postId);
+    }
+    async listReadyPosts(customerId) {
+        return this.listByCustomer("ready_post", customerId);
+    }
+    async archiveReadyPost(customerId, postId) {
+        const post = await this.getReadyPost(postId);
+        if (!post || post.customerId !== customerId)
+            return null;
+        return this.putRecord("ready_post", { ...post, status: "archived", archivedAt: nowIso(), updatedAt: nowIso() });
+    }
+    async deleteReadyPost(customerId, postId) {
+        const post = await this.getReadyPost(postId);
+        if (!post || post.customerId !== customerId)
+            return null;
+        const updated = await this.putRecord("ready_post", { ...post, status: "deleted", deletedAt: nowIso(), updatedAt: nowIso() });
+        return updated;
+    }
+    async setReadyPostZip(input) {
+        const post = await this.getReadyPost(input.postId);
+        if (!post || post.customerId !== input.customerId)
+            return null;
+        return this.putRecord("ready_post", {
+            ...post,
+            zipStorageKey: input.zipStorageKey,
+            zipPublicUrl: input.zipPublicUrl,
+            updatedAt: nowIso()
+        });
+    }
+    async createPostSchedule(input) {
+        const timestamp = nowIso();
+        return this.putRecord("post_schedule", {
+            id: input.id ?? createId("sched"),
+            customerId: input.customerId,
+            readyPostId: input.readyPostId ?? null,
+            managedBy: input.managedBy ?? "vidfarm",
+            provider: input.provider ?? "flockposter",
+            destinationType: input.destinationType ?? "flockposter",
+            destinationId: input.destinationId ?? "",
+            scheduledAt: input.scheduledAt ?? timestamp,
+            timezone: input.timezone ?? null,
+            status: input.status ?? "scheduled",
+            providerStatus: input.providerStatus ?? null,
+            providerScheduleId: input.providerScheduleId ?? null,
+            title: input.title ?? null,
+            summary: input.summary ?? null,
+            url: input.url ?? null,
+            additionalNotes: input.additionalNotes ?? null,
+            providerPayload: input.providerPayload ?? {},
+            providerResponse: input.providerResponse ?? {},
+            lastSyncedAt: input.lastSyncedAt ?? null,
+            lastError: input.lastError ?? null,
+            cancelledAt: input.cancelledAt ?? null,
+            sentAt: input.sentAt ?? null,
+            createdAt: input.createdAt ?? timestamp,
+            updatedAt: timestamp
+        });
+    }
+    async getPostSchedule(customerId, scheduleId) {
+        const schedule = await this.getById("post_schedule", scheduleId);
+        return schedule?.customerId === customerId ? schedule : null;
+    }
+    async listPostSchedulesForPost(customerId, readyPostId) {
+        return (await this.listByCustomer("post_schedule", customerId)).filter((schedule) => schedule.readyPostId === readyPostId);
+    }
+    async listPostSchedulesForCalendar(input) {
+        return (await this.listByCustomer("post_schedule", input.customerId)).filter((schedule) => {
+            const scheduledAt = String(schedule.scheduledAt ?? "");
+            if (input.startTime && scheduledAt < input.startTime)
+                return false;
+            if (input.endTime && scheduledAt > input.endTime)
+                return false;
+            return true;
+        });
+    }
+    async updatePostScheduleProvider(input) {
+        return this.mergeByIdForCustomer("post_schedule", input.customerId, input.scheduleId, input);
+    }
+    async markPostScheduleCancelled(input) {
+        return this.mergeByIdForCustomer("post_schedule", input.customerId, input.scheduleId, {
+            ...input,
+            status: "cancelled",
+            cancelledAt: nowIso()
+        });
+    }
+    async markPostScheduleFailed(input) {
+        return this.mergeByIdForCustomer("post_schedule", input.customerId, input.scheduleId, {
+            ...input,
+            status: "failed",
+            lastError: input.lastError ?? "Schedule failed"
+        });
+    }
+    async upsertExternalPostSchedule(input) {
+        const existing = (await this.listByCustomer("post_schedule", input.customerId))
+            .find((schedule) => schedule.providerScheduleId === input.providerScheduleId);
+        return this.createPostSchedule({ ...existing, ...input, managedBy: "external" });
+    }
+    async createEmailChannel(input) {
+        const timestamp = nowIso();
+        return this.putRecord("email_channel", {
+            id: input.id ?? createId("email"),
+            customerId: input.customerId,
+            title: input.title ?? input.email,
+            email: input.email,
+            note: input.note ?? null,
+            avatarUrl: input.avatarUrl ?? null,
+            avatarStorageKey: input.avatarStorageKey ?? null,
+            status: input.status ?? "unverified",
+            verificationTokenHash: input.verificationTokenHash ?? null,
+            verificationSentAt: input.verificationSentAt ?? null,
+            verifiedAt: input.verifiedAt ?? null,
+            createdAt: input.createdAt ?? timestamp,
+            updatedAt: timestamp
+        });
+    }
+    async listEmailChannels(customerId) {
+        return this.listByCustomer("email_channel", customerId);
+    }
+    async getEmailChannel(customerId, channelId) {
+        const channel = await this.getById("email_channel", channelId);
+        return channel?.customerId === customerId ? channel : null;
+    }
+    async getEmailChannelByEmail(customerId, email) {
+        return (await this.listEmailChannels(customerId)).find((channel) => channel.email.toLowerCase() === email.toLowerCase()) ?? null;
+    }
+    async updateEmailChannel(input) {
+        return this.mergeByIdForCustomer("email_channel", input.customerId, input.channelId, input);
+    }
+    async updateEmailChannelAvatar(input) {
+        await this.updateEmailChannel(input);
+    }
+    async updateEmailChannelVerification(input) {
+        return this.updateEmailChannel(input);
+    }
+    async verifyEmailChannelByTokenHash(tokenHash) {
+        const response = await dynamodb.send(new ScanCommand({
+            TableName: requireMainTableName(),
+            FilterExpression: "entity_type = :type AND verificationTokenHash = :token",
+            ExpressionAttributeValues: {
+                ":type": "serverless_record#email_channel",
+                ":token": tokenHash
+            },
+            Limit: 1
+        }));
+        const channel = response.Items?.[0]?.data;
+        if (!channel)
+            return null;
+        return this.putRecord("email_channel", {
+            ...channel,
+            status: "verified",
+            verifiedAt: nowIso(),
+            verificationTokenHash: null,
+            updatedAt: nowIso()
+        });
+    }
+    async deleteEmailChannel(customerId, channelId) {
+        const existing = await this.getEmailChannel(customerId, channelId);
+        if (existing)
+            await this.deleteById("email_channel", channelId);
+    }
+    async createUserAttachment(input) {
+        const timestamp = nowIso();
+        return this.putRecord("user_attachment", {
+            id: input.id ?? createId("att"),
+            customerId: input.customerId,
+            fileName: input.fileName,
+            contentType: input.contentType ?? "application/octet-stream",
+            sizeBytes: input.sizeBytes ?? 0,
+            storageKey: input.storageKey,
+            folderPath: normalizeFolder(input.folderPath),
+            publicUrl: input.publicUrl ?? null,
+            createdAt: input.createdAt ?? timestamp
+        });
+    }
+    async listUserAttachments(customerId) {
+        return this.listByCustomer("user_attachment", customerId);
+    }
+    async getUserAttachment(customerId, attachmentId) {
+        const attachment = await this.getById("user_attachment", attachmentId);
+        return attachment?.customerId === customerId ? attachment : null;
+    }
+    async deleteUserAttachment(customerId, attachmentId) {
+        const existing = await this.getUserAttachment(customerId, attachmentId);
+        if (existing)
+            await this.deleteById("user_attachment", attachmentId);
+    }
+    async createUserTemporaryFile(input) {
+        const timestamp = nowIso();
+        return this.putRecord("user_temporary_file", {
+            id: input.id ?? createId("tmp"),
+            customerId: input.customerId,
+            fileName: input.fileName,
+            contentType: input.contentType ?? "application/octet-stream",
+            sizeBytes: input.sizeBytes ?? 0,
+            storageKey: input.storageKey,
+            folderPath: normalizeFolder(input.folderPath),
+            expiresAt: input.expiresAt ?? timestamp,
+            createdAt: input.createdAt ?? timestamp
+        });
+    }
+    async listUserTemporaryFiles(customerId) {
+        return this.listByCustomer("user_temporary_file", customerId);
+    }
+    async getUserTemporaryFile(customerId, fileId) {
+        const file = await this.getById("user_temporary_file", fileId);
+        return file?.customerId === customerId ? file : null;
+    }
+    async deleteUserTemporaryFile(customerId, fileId) {
+        const existing = await this.getUserTemporaryFile(customerId, fileId);
+        if (existing)
+            await this.deleteById("user_temporary_file", fileId);
+    }
+    async deleteExpiredUserTemporaryFiles() {
+        const now = nowIso();
+        const files = (await this.scanCollection("user_temporary_file"))
+            .filter(isExpiredUserTemporaryFileRecord);
+        const expired = files.filter((file) => file.expiresAt <= now);
+        for (const file of expired)
+            await this.deleteById("user_temporary_file", file.id);
+        return expired;
+    }
+    async createUserFileFolder(customerId, scope, folderPath) {
+        const normalized = normalizeFolder(folderPath);
+        await this.putRecord("user_file_folder", {
+            id: `${customerId}:${scope}:${normalized}`,
+            customerId,
+            scope,
+            folderPath: normalized
+        });
+    }
+    async listUserFileFolders(customerId, scope) {
+        return (await this.listByCustomer("user_file_folder", customerId))
+            .filter((folder) => folder.scope === scope)
+            .map((folder) => String(folder.folderPath));
+    }
+    async moveUserFileFolder(customerId, scope, fromFolder, toFolder) {
+        await this.deleteUserFileFolder(customerId, scope, fromFolder);
+        await this.createUserFileFolder(customerId, scope, toFolder);
+    }
+    async deleteUserFileFolder(customerId, scope, folderPath) {
+        await this.deleteById("user_file_folder", `${customerId}:${scope}:${normalizeFolder(folderPath)}`);
+    }
+    async moveUserAttachmentFolder(customerId, fromFolder, toFolder) {
+        await this.moveCollectionFolder("user_attachment", customerId, fromFolder, toFolder);
+    }
+    async deleteUserAttachmentFolder(customerId, folderPath) {
+        return this.deleteCollectionFolder("user_attachment", customerId, folderPath);
+    }
+    async moveUserTemporaryFolder(customerId, fromFolder, toFolder) {
+        await this.moveCollectionFolder("user_temporary_file", customerId, fromFolder, toFolder);
+    }
+    async deleteUserTemporaryFolder(customerId, folderPath) {
+        return this.deleteCollectionFolder("user_temporary_file", customerId, folderPath);
+    }
+    async queueWebhookDelivery(input) {
+        const timestamp = nowIso();
+        await this.putRecord("webhook_delivery", {
+            id: typeof input.id === "string" ? input.id : createId("webhook"),
+            customerId: typeof input.customerId === "string" ? input.customerId : undefined,
+            jobId: input.jobId,
+            destinationUrl: input.destinationUrl,
+            destination_url: input.destinationUrl,
+            eventType: input.eventType,
+            event_type: input.eventType,
+            payload: input.payload,
+            payload_json: JSON.stringify(input.payload ?? {}),
+            status: "pending",
+            attemptCount: 0,
+            attempt_count: 0,
+            nextAttemptAt: timestamp,
+            next_attempt_at: timestamp,
+            createdAt: timestamp,
+            updatedAt: timestamp
+        });
+    }
+    async listPendingWebhookDeliveries(limit = 100) {
+        const response = await dynamodb.send(new ScanCommand({
+            TableName: requireMainTableName(),
+            FilterExpression: "entity_type = :type AND #data.#status = :status",
+            ExpressionAttributeNames: { "#data": "data", "#status": "status" },
+            ExpressionAttributeValues: {
+                ":type": "serverless_record#webhook_delivery",
+                ":status": "pending"
+            },
+            Limit: limit
+        }));
+        return (response.Items ?? []).map((item) => item.data);
+    }
+    async markWebhookDelivery(input) {
+        const existing = await this.getById("webhook_delivery", input.id);
+        if (!existing)
+            return;
+        await this.putRecord("webhook_delivery", {
+            ...existing,
+            ...input,
+            attempt_count: input.attemptCount ?? input.attempt_count ?? existing.attempt_count,
+            next_attempt_at: input.nextAttemptAt ?? input.next_attempt_at ?? existing.next_attempt_at,
+            updatedAt: nowIso()
+        });
+    }
+    async listChatThreadMetas(input) {
+        const limit = Math.max(1, Math.min(input.limit ?? 100, 500));
+        return (await this.listByCustomer("chat_thread", input.customerId))
+            .filter((thread) => !input.templateId || thread.templateId === input.templateId)
+            .sort((a, b) => String(b.updatedAt ?? "").localeCompare(String(a.updatedAt ?? "")))
+            .slice(0, limit);
+    }
+    async getChatThreadMeta(customerId, threadId) {
+        const thread = await this.getById("chat_thread", threadId);
+        return thread?.customerId === customerId ? thread : null;
+    }
+    async appendChatThreadMessages(input) {
+        const existing = await this.getChatThreadMeta(input.customerId, input.threadId);
+        const timestamp = nowIso();
+        const thread = {
+            id: input.threadId,
+            customerId: input.customerId,
+            templateId: input.templateId,
+            title: input.title,
+            storagePrefix: input.storagePrefix,
+            tracers: input.tracers,
+            messageCount: (existing?.messageCount ?? 0) + input.messageCountDelta,
+            lastMessageAt: input.lastMessageAt,
+            hiddenFromView: existing?.hiddenFromView ?? false,
+            archivedAt: existing?.archivedAt ?? null,
+            createdAt: existing?.createdAt ?? timestamp,
+            updatedAt: timestamp,
+            messages: []
+        };
+        return this.putRecord("chat_thread", thread);
+    }
+    async updateChatThreadState(input) {
+        const existing = await this.getChatThreadMeta(input.customerId, input.threadId);
+        if (!existing)
+            return null;
+        return this.putRecord("chat_thread", {
+            ...existing,
+            title: input.title ?? existing.title,
+            tracers: input.tracers ?? existing.tracers,
+            hiddenFromView: input.hiddenFromView ?? existing.hiddenFromView,
+            archivedAt: input.archivedAt === undefined ? existing.archivedAt : input.archivedAt,
+            updatedAt: nowIso()
+        });
+    }
+    async deleteChatThread(customerId, threadId) {
+        const existing = await this.getChatThreadMeta(customerId, threadId);
+        if (!existing)
+            return null;
+        await this.deleteById("chat_thread", threadId);
+        return existing;
+    }
+    async createTemplateSource(input) {
+        return this.putRecord("template_source", { id: input.id ?? createId("tsrc"), ...input });
+    }
+    async updateTemplateSource(input) {
+        const existing = await this.getById("template_source", String(input.id));
+        return this.putRecord("template_source", { ...existing, ...input, updatedAt: nowIso() });
+    }
+    async getTemplateSource(sourceId) {
+        return this.getById("template_source", sourceId);
+    }
+    async getTemplateSourceByTemplateId(templateId) {
+        return this.findByScan("template_source", (item) => item.templateId === templateId);
+    }
+    async getTemplateSourceBySlugId(slugId) {
+        return this.findByScan("template_source", (item) => item.slugId === slugId);
+    }
+    async getTemplateSourceByLocation(repoUrl, branch, templateModulePath) {
+        return this.findByScan("template_source", (item) => item.repoUrl === repoUrl && item.branch === branch && item.templateModulePath === templateModulePath);
+    }
+    async listTemplateSources() {
+        return this.scanCollection("template_source");
+    }
+    async createTemplateRelease(input) {
+        return this.putRecord("template_release", { id: input.id ?? createId("trel"), ...input });
+    }
+    async getTemplateRelease(releaseId) {
+        return this.getById("template_release", releaseId);
+    }
+    async getTemplateReleaseBySourceAndCommit(sourceId, commitSha) {
+        return this.findByScan("template_release", (item) => item.sourceId === sourceId && item.commitSha === commitSha);
+    }
+    async getLatestTemplateReleaseForSource(sourceId) {
+        return (await this.scanCollection("template_release"))
+            .filter((release) => release.sourceId === sourceId)
+            .sort((a, b) => String(b.createdAt ?? "").localeCompare(String(a.createdAt ?? "")))[0] ?? null;
+    }
+    async listTemplateReleases() {
+        return this.scanCollection("template_release");
+    }
+    async listActiveTemplateReleases() {
+        const releases = [];
+        let cursor = null;
+        do {
+            const page = await this.listActiveTemplateReleasePage({ cursor, limit: 500 });
+            releases.push(...page.items);
+            cursor = page.nextCursor;
+        } while (cursor);
+        return releases;
+    }
+    async listActiveTemplateReleasePage(input = {}) {
+        const limit = Math.max(1, Math.min(input.limit ?? 100, 500));
+        const releases = [];
+        let ExclusiveStartKey = decodeDynamoCursor(input.cursor);
+        do {
+            const response = await dynamodb.send(new QueryCommand({
+                TableName: requireMainTableName(),
+                IndexName: "gsi1",
+                KeyConditionExpression: "gsi1pk = :pk",
+                FilterExpression: "#data.#record_kind = :kind",
+                ExpressionAttributeNames: {
+                    "#data": "data",
+                    "#record_kind": "recordKind"
+                },
+                ExpressionAttributeValues: {
+                    ":pk": collectionPk("active_template"),
+                    ":kind": "active_template_release"
+                },
+                ScanIndexForward: false,
+                Limit: Math.max(1, limit - releases.length),
+                ExclusiveStartKey
+            }));
+            releases.push(...(response.Items ?? []).map((item) => item.data));
+            ExclusiveStartKey = response.LastEvaluatedKey;
+        } while (ExclusiveStartKey && releases.length < limit);
+        return {
+            items: releases,
+            nextCursor: encodeDynamoCursor(ExclusiveStartKey)
+        };
+    }
+    async getActiveTemplateReleaseByTemplateId(templateId) {
+        const direct = await this.getById("active_template", templateId);
+        if (direct?.recordKind === "active_template_release") {
+            return direct;
+        }
+        const alias = await this.getById("active_template", activeTemplateSlugAliasId(templateId));
+        if (alias?.recordKind === "active_template_slug_alias" && typeof alias.templateId === "string") {
+            const release = await this.getById("active_template", alias.templateId);
+            return release?.recordKind === "active_template_release"
+                ? release
+                : null;
+        }
+        return null;
+    }
+    async putActiveTemplateRelease(release) {
+        const slugId = release.templateSnapshot?.slugId;
+        const data = await this.putRecord("active_template", {
+            ...release,
+            id: release.templateId,
+            recordKind: "active_template_release",
+            updatedAt: release.activatedAt ?? release.updatedAt ?? nowIso()
+        });
+        if (slugId) {
+            await this.putRecord("active_template", {
+                id: activeTemplateSlugAliasId(slugId),
+                recordKind: "active_template_slug_alias",
+                templateId: release.templateId,
+                slugId,
+                releaseId: release.id,
+                updatedAt: release.activatedAt ?? release.updatedAt ?? nowIso()
+            });
+        }
+        return data;
+    }
+    async updateTemplateReleaseStatus(input) {
+        const existing = await this.getById("template_release", input.releaseId);
+        if (existing)
+            await this.putRecord("template_release", { ...existing, ...input, id: input.releaseId, updatedAt: nowIso() });
+    }
+    async clearActiveTemplateReleases(templateId) {
+        const active = await this.getActiveTemplateReleaseByTemplateId(templateId);
+        if (active) {
+            await this.putRecord("template_release", { ...active, id: String(active.id), status: "approved", activatedAt: null, updatedAt: nowIso() });
+            await this.deleteById("active_template", active.templateId);
+            if (active.templateSnapshot?.slugId) {
+                await this.deleteById("active_template", activeTemplateSlugAliasId(active.templateSnapshot.slugId));
+            }
+        }
+    }
+    async call(method, args) {
+        const collection = METHOD_COLLECTIONS[method];
+        if (!collection) {
+            throw new Error(`Serverless record method ${method} is not implemented.`);
+        }
+        devLog("serverless_records.dynamic_call", { method, collection });
+        throw new Error(`Serverless record method ${method} requires a typed implementation.`);
+    }
+    async mergeByIdForCustomer(collection, customerId, id, patch) {
+        const existing = await this.getById(collection, id);
+        if (!existing || existing.customerId !== customerId)
+            return null;
+        return this.putRecord(collection, { ...existing, ...patch, id, customerId, updatedAt: nowIso() });
+    }
+    async moveCollectionFolder(collection, customerId, fromFolder, toFolder) {
+        for (const record of await this.listByCustomer(collection, customerId)) {
+            if (normalizeFolder(String(record.folderPath ?? "")) === normalizeFolder(fromFolder)) {
+                await this.putRecord(collection, { ...record, folderPath: normalizeFolder(toFolder), updatedAt: nowIso() });
+            }
+        }
+    }
+    async deleteCollectionFolder(collection, customerId, folderPath) {
+        const deleted = [];
+        for (const record of await this.listByCustomer(collection, customerId)) {
+            if (normalizeFolder(String(record.folderPath ?? "")) === normalizeFolder(folderPath)) {
+                await this.deleteById(collection, String(record.id));
+                deleted.push(record);
+            }
+        }
+        return deleted;
+    }
+    async findByScan(collection, predicate) {
+        return (await this.scanCollection(collection)).find(predicate) ?? null;
+    }
+    async scanCollection(collection) {
+        const results = [];
+        let exclusiveStartKey;
+        // DDB Scan with FilterExpression only reads one page at a time; matching
+        // items later in the table are silently dropped unless you follow
+        // LastEvaluatedKey. Paginate until DDB stops returning a cursor.
+        do {
+            const response = await dynamodb.send(new ScanCommand({
+                TableName: requireMainTableName(),
+                FilterExpression: "entity_type = :type",
+                ExpressionAttributeValues: {
+                    ":type": entityType(collection)
+                },
+                ExclusiveStartKey: exclusiveStartKey
+            }));
+            for (const item of response.Items ?? []) {
+                results.push(item.data);
+            }
+            exclusiveStartKey = response.LastEvaluatedKey;
+        } while (exclusiveStartKey);
+        return results;
+    }
+    async listByCustomer(collection, customerId) {
+        return this.listByPartition(collection, customerCollectionPk(collection, customerId));
+    }
+    async listByPartition(_collection, partitionKey) {
+        const response = await dynamodb.send(new QueryCommand({
+            TableName: requireMainTableName(),
+            IndexName: "gsi1",
+            KeyConditionExpression: "gsi1pk = :pk",
+            ExpressionAttributeValues: {
+                ":pk": partitionKey
+            },
+            ScanIndexForward: false
+        }));
+        return (response.Items ?? []).map((item) => item.data);
+    }
+    async getById(collection, id) {
+        const response = await dynamodb.send(new GetCommand({
+            TableName: requireMainTableName(),
+            Key: recordKey(collection, id)
+        }));
+        return response.Item?.data ?? null;
+    }
+    async deleteById(collection, id) {
+        await dynamodb.send(new DeleteCommand({
+            TableName: requireMainTableName(),
+            Key: recordKey(collection, id)
+        }));
+        devLog("serverless_records.deleted", { collection, id });
+    }
+    async putRecord(collection, record, options) {
+        const timestamp = nowIso();
+        const id = typeof record.id === "string" && record.id ? record.id : createId("rec");
+        const data = {
+            ...record,
+            id,
+            createdAt: record.createdAt ?? timestamp,
+            updatedAt: record.updatedAt ?? timestamp
+        };
+        const gsi1pk = options?.partitionKey
+            ?? (data.customerId ? customerCollectionPk(collection, String(data.customerId)) : collectionPk(collection));
+        await dynamodb.send(new PutCommand({
+            TableName: requireMainTableName(),
+            Item: {
+                ...recordKey(collection, id),
+                entity_type: entityType(collection),
+                gsi1pk,
+                gsi1sk: `${String(data.updatedAt)}#${id}`,
+                data
+            }
+        }));
+        devLog("serverless_records.put", {
+            collection,
+            id,
+            customer_id: data.customerId ?? null,
+            partition_key: gsi1pk
+        });
+        return data;
+    }
+}
+function forkPartitionPk(collection, forkId) {
+    return `FORK#${forkId}#${collection}`;
+}
+function requireMainTableName() {
+    if (!config.VIDFARM_SERVERLESS_MAIN_TABLE_NAME) {
+        throw new Error("Serverless record store requires VIDFARM_SERVERLESS_MAIN_TABLE_NAME.");
+    }
+    return config.VIDFARM_SERVERLESS_MAIN_TABLE_NAME;
+}
+function recordKey(collection, id) {
+    return {
+        pk: `${collectionPk(collection)}#${id}`,
+        sk: "META"
+    };
+}
+function collectionPk(collection) {
+    return `SERVERLESS_RECORD#${collection}`;
+}
+function activeTemplateSlugAliasId(slugId) {
+    return `slug#${slugId}`;
+}
+function encodeDynamoCursor(value) {
+    return value ? Buffer.from(JSON.stringify(value), "utf8").toString("base64url") : null;
+}
+function decodeDynamoCursor(raw) {
+    if (!raw) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(Buffer.from(raw, "base64url").toString("utf8"));
+        return parsed && typeof parsed === "object" ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function customerCollectionPk(collection, customerId) {
+    return `CUSTOMER#${customerId}#${collection}`;
+}
+function entityType(collection) {
+    return `serverless_record#${collection}`;
+}
+function normalizeFolder(value) {
+    if (typeof value !== "string")
+        return "";
+    return value.trim().replace(/^\/+|\/+$/g, "");
+}
+function isExpiredUserTemporaryFileRecord(record) {
+    return typeof record.id === "string"
+        && record.id.length > 0
+        && typeof record.expiresAt === "string"
+        && record.expiresAt.length > 0;
+}
+function itemToCustomer(item) {
+    return {
+        id: String(item.customer_id),
+        email: String(item.email),
+        name: typeof item.name === "string" ? item.name : null,
+        defaultWebhookUrl: typeof item.default_webhook_url === "string" ? item.default_webhook_url : null,
+        isDeveloper: Boolean(item.is_developer),
+        isAgency: Boolean(item.is_agency),
+        isPaidPlan: Boolean(item.is_paid_plan),
+        planTier: item.plan_tier === "standalone" || item.plan_tier === "agency" ? item.plan_tier : "client",
+        about: typeof item.about === "string" ? item.about : null,
+        groupchatUrl: typeof item.groupchat_url === "string" ? item.groupchat_url : null,
+        flockposterApiKey: typeof item.flockposter_api_key === "string" ? item.flockposter_api_key : null,
+        createdAt: typeof item.created_at === "string" ? item.created_at : nowIso(),
+        updatedAt: typeof item.updated_at === "string" ? item.updated_at : nowIso()
+    };
+}
+export const serverlessRecords = new ServerlessRecordsServiceImpl();
+//# sourceMappingURL=serverless-records.js.map