@mevdragon/vidfarm-devcli 0.2.13 → 0.3.0

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

@@ -1,1086 +0,0 @@
-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",
-            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