@mevdragon/vidfarm-devcli 0.5.3 → 0.6.0

package/dist/src/services/serverless-template-configs.js

@@ -0,0 +1,75 @@
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient, GetCommand, PutCommand } from "@aws-sdk/lib-dynamodb";
+import { config } from "../config.js";
+import { devLog } from "../lib/dev-log.js";
+import { nowIso } from "../lib/time.js";
+import { createLocalDynamoClient } from "./local-dynamo.js";
+// `vidfarm serve` (RECORDS_DRIVER=local) swaps in the disk-backed shim so
+// template configs live on disk; deployed environments keep the real client.
+const dynamodb = config.RECORDS_DRIVER === "local"
+    ? createLocalDynamoClient()
+    : DynamoDBDocumentClient.from(new DynamoDBClient({}), {
+        marshallOptions: {
+            removeUndefinedValues: true
+        }
+    });
+export class ServerlessTemplateConfigService {
+    async getTemplateConfig(customerId, templateId) {
+        const response = await dynamodb.send(new GetCommand({
+            TableName: requireMainTableName(),
+            Key: templateConfigKey(customerId, templateId)
+        }));
+        const item = response.Item;
+        const configJson = item && isRecord(item.config_json) ? item.config_json : {};
+        devLog("template_config.get", {
+            customer_id: customerId,
+            template_id: templateId,
+            found: Boolean(item),
+            key_count: Object.keys(configJson).length
+        });
+        return configJson;
+    }
+    async upsertTemplateConfig(input) {
+        const timestamp = nowIso();
+        await dynamodb.send(new PutCommand({
+            TableName: requireMainTableName(),
+            Item: {
+                ...templateConfigKey(input.customerId, input.templateId),
+                entity_type: "TemplateConfig",
+                gsi1pk: `CUSTOMER#${input.customerId}#TEMPLATE_CONFIGS`,
+                gsi1sk: `TEMPLATE#${input.templateId}`,
+                config_id: input.id,
+                customer_id: input.customerId,
+                template_id: input.templateId,
+                config_json: input.config,
+                created_at: timestamp,
+                updated_at: timestamp
+            }
+        }));
+        devLog("template_config.upserted", {
+            config_id: input.id,
+            customer_id: input.customerId,
+            template_id: input.templateId,
+            key_count: Object.keys(input.config).length
+        });
+    }
+}
+function requireMainTableName() {
+    if (config.RECORDS_DRIVER === "local") {
+        return config.VIDFARM_SERVERLESS_MAIN_TABLE_NAME || "vidfarm-local-main";
+    }
+    if (!config.VIDFARM_SERVERLESS_MAIN_TABLE_NAME) {
+        throw new Error("Serverless template config store requires VIDFARM_SERVERLESS_MAIN_TABLE_NAME.");
+    }
+    return config.VIDFARM_SERVERLESS_MAIN_TABLE_NAME;
+}
+function templateConfigKey(customerId, templateId) {
+    return {
+        pk: `CUSTOMER#${customerId}#TEMPLATE#${templateId}`,
+        sk: "CONFIG"
+    };
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+//# sourceMappingURL=serverless-template-configs.js.map

package/dist/src/services/storage.js

@@ -0,0 +1,383 @@
+import { mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { DeleteObjectCommand, GetObjectCommand, HeadObjectCommand, ListObjectsV2Command, PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+import { config } from "../config.js";
+function isS3NotFoundError(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const record = error;
+    const name = typeof record.name === "string" ? record.name : "";
+    const code = typeof record.Code === "string" ? record.Code : "";
+    const metadata = record.$metadata;
+    const httpStatusCode = typeof metadata?.httpStatusCode === "number" ? metadata.httpStatusCode : undefined;
+    return name === "NoSuchKey" || code === "NoSuchKey" || name === "NotFound" || httpStatusCode === 404;
+}
+export class StorageService {
+    localRoot = path.join(config.VIDFARM_DATA_DIR, "storage");
+    s3 = config.STORAGE_DRIVER === "s3"
+        ? new S3Client({
+            region: config.AWS_REGION,
+            endpoint: config.AWS_S3_ENDPOINT || undefined
+        })
+        : null;
+    constructor() {
+        mkdirSync(this.localRoot, { recursive: true });
+    }
+    userAttachmentKey(customerId, attachmentId, fileName, folderPath) {
+        return joinStorageKey("users", customerId, "files", folderPath || "", attachmentId, fileName);
+    }
+    legacyUserAttachmentKey(customerId, attachmentId, fileName) {
+        return joinStorageKey("users", customerId, attachmentId, fileName);
+    }
+    userTemporaryFileKey(customerId, fileId, fileName, folderPath) {
+        return joinStorageKey("users", customerId, "temporary", folderPath || "", fileId, fileName);
+    }
+    developerAttachmentKey(customerId, attachmentId, fileName) {
+        return joinStorageKey("developer", customerId, "attachments", attachmentId, fileName);
+    }
+    developerScopedKey(customerId, ...parts) {
+        return joinStorageKey("developer", customerId, ...parts);
+    }
+    templateJobPrefix(templateId, customerId, jobId) {
+        return joinStorageKey("templates", templateId, "users", customerId, "jobs", jobId);
+    }
+    templateJobKey(templateId, customerId, jobId, key) {
+        return joinStorageKey(this.templateJobPrefix(templateId, customerId, jobId), key);
+    }
+    primitiveJobPrefix(primitiveId, customerId, jobId) {
+        return joinStorageKey("primitives", primitiveId, "users", customerId, "jobs", jobId);
+    }
+    primitiveJobKey(primitiveId, customerId, jobId, key) {
+        return joinStorageKey(this.primitiveJobPrefix(primitiveId, customerId, jobId), key);
+    }
+    templateAboutKey(templateId, assetPath) {
+        return joinStorageKey("templates", templateId, "about", assetPath);
+    }
+    compositionForkRoot(forkId) {
+        return joinStorageKey("compositions", "forks", forkId);
+    }
+    compositionForkWorkingPrefix(forkId) {
+        return joinStorageKey(this.compositionForkRoot(forkId), "working");
+    }
+    compositionForkWorkingKey(forkId, filename) {
+        return joinStorageKey(this.compositionForkWorkingPrefix(forkId), filename);
+    }
+    compositionForkVersionPrefix(forkId, version) {
+        return joinStorageKey(this.compositionForkRoot(forkId), "versions", String(version));
+    }
+    compositionForkVersionKey(forkId, version, filename) {
+        return joinStorageKey(this.compositionForkVersionPrefix(forkId, version), filename);
+    }
+    submittedVideoPrefix(videoId) {
+        return joinStorageKey("videos", videoId);
+    }
+    submittedVideoKey(videoId, filename) {
+        return joinStorageKey(this.submittedVideoPrefix(videoId), filename);
+    }
+    async putJson(key, value) {
+        const body = JSON.stringify(value, null, 2);
+        return this.putBuffer(key, Buffer.from(body, "utf8"), "application/json");
+    }
+    async putText(key, value, contentType = "text/plain; charset=utf-8") {
+        return this.putBuffer(key, Buffer.from(value, "utf8"), contentType);
+    }
+    // Uploads to S3 (or the local dev filesystem) and returns the key plus a
+    // public URL when the key is in a public-policy prefix. The old
+    // `publicRead` argument was a lie — bucket-level policy decides what's
+    // public, not per-call flags — so it's been removed.
+    async putBuffer(key, value, contentType = "application/octet-stream") {
+        if (this.s3 && config.AWS_S3_BUCKET) {
+            await this.s3.send(new PutObjectCommand({
+                Bucket: config.AWS_S3_BUCKET,
+                Key: key,
+                Body: value,
+                ContentType: contentType
+            }));
+            return { key, url: this.getPublicUrl(key) };
+        }
+        const filePath = this.resolveLocalPath(key);
+        mkdirSync(path.dirname(filePath), { recursive: true });
+        writeFileSync(filePath, value);
+        return { key, url: this.getPublicUrl(key) };
+    }
+    // Returns a directly-fetchable URL for a storage key when the key is
+    // stored under a prefix the bucket resource policy grants public read to.
+    // Callers get a real S3 URL that browsers/CDNs/GhostCut/etc. can hit
+    // without any Lambda proxy hop. Returns null for keys under private
+    // prefixes — callers who need to serve those must do access-checked
+    // reads through their own endpoint.
+    getPublicUrl(key) {
+        let normalizedKey;
+        try {
+            normalizedKey = normalizeStorageKey(key);
+        }
+        catch {
+            return null;
+        }
+        if (this.s3 && config.AWS_S3_BUCKET) {
+            if (!isPublicStorageKey(normalizedKey)) {
+                return null;
+            }
+            const encodedKey = normalizedKey.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+            if (config.AWS_S3_ENDPOINT) {
+                return `${config.AWS_S3_ENDPOINT.replace(/\/$/, "")}/${config.AWS_S3_BUCKET}/${encodedKey}`;
+            }
+            return `https://${config.AWS_S3_BUCKET}.s3.${config.AWS_REGION}.amazonaws.com/${encodedKey}`;
+        }
+        return `${config.PUBLIC_BASE_URL}/storage/${encodeURIComponent(normalizedKey)}`;
+    }
+    readLocalJson(key) {
+        return JSON.parse(readFileSync(this.resolveLocalPath(key), "utf8"));
+    }
+    readLocalObject(key) {
+        const filePath = this.resolveLocalPath(key);
+        const body = readFileSync(filePath);
+        return {
+            body,
+            contentType: inferContentType(filePath)
+        };
+    }
+    async getReadUrl(key) {
+        return this.createReadUrl(key);
+    }
+    async createWriteUrl(key, input) {
+        if (!this.s3 || !config.AWS_S3_BUCKET) {
+            throw new Error("Presigned uploads require S3 storage.");
+        }
+        const expiresIn = input.expiresIn ?? 3600;
+        const command = new PutObjectCommand({
+            Bucket: config.AWS_S3_BUCKET,
+            Key: key,
+            ContentType: input.contentType
+        });
+        return {
+            url: await getSignedUrl(this.s3, command, { expiresIn }),
+            method: "PUT",
+            headers: {
+                "content-type": input.contentType
+            },
+            expiresIn
+        };
+    }
+    async readText(key) {
+        if (this.s3 && config.AWS_S3_BUCKET) {
+            try {
+                const response = await this.s3.send(new GetObjectCommand({
+                    Bucket: config.AWS_S3_BUCKET,
+                    Key: key
+                }));
+                if (!response.Body) {
+                    return null;
+                }
+                return response.Body.transformToString();
+            }
+            catch (error) {
+                if (isS3NotFoundError(error))
+                    return null;
+                throw error;
+            }
+        }
+        try {
+            return readFileSync(this.resolveLocalPath(key), "utf8");
+        }
+        catch (error) {
+            if (error?.code === "ENOENT")
+                return null;
+            throw error;
+        }
+    }
+    async readBuffer(key) {
+        if (this.s3 && config.AWS_S3_BUCKET) {
+            try {
+                const response = await this.s3.send(new GetObjectCommand({
+                    Bucket: config.AWS_S3_BUCKET,
+                    Key: key
+                }));
+                if (!response.Body) {
+                    return null;
+                }
+                return Buffer.from(await response.Body.transformToByteArray());
+            }
+            catch (error) {
+                if (isS3NotFoundError(error))
+                    return null;
+                throw error;
+            }
+        }
+        try {
+            return readFileSync(this.resolveLocalPath(key));
+        }
+        catch (error) {
+            if (error?.code === "ENOENT")
+                return null;
+            throw error;
+        }
+    }
+    async listKeys(prefix) {
+        if (this.s3 && config.AWS_S3_BUCKET) {
+            const keys = [];
+            let continuationToken;
+            do {
+                const response = await this.s3.send(new ListObjectsV2Command({
+                    Bucket: config.AWS_S3_BUCKET,
+                    Prefix: prefix,
+                    ContinuationToken: continuationToken
+                }));
+                for (const object of response.Contents ?? []) {
+                    if (object.Key) {
+                        keys.push(object.Key);
+                    }
+                }
+                continuationToken = response.IsTruncated ? response.NextContinuationToken : undefined;
+            } while (continuationToken);
+            return keys;
+        }
+        const root = path.join(this.localRoot, prefix);
+        const keys = [];
+        walkLocalTree(root, (filePath) => {
+            keys.push(path.relative(this.localRoot, filePath).split(path.sep).join("/"));
+        });
+        return keys;
+    }
+    async objectExists(key) {
+        if (this.s3 && config.AWS_S3_BUCKET) {
+            try {
+                await this.s3.send(new HeadObjectCommand({
+                    Bucket: config.AWS_S3_BUCKET,
+                    Key: key
+                }));
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+        try {
+            readFileSync(this.resolveLocalPath(key));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async deleteObject(key) {
+        if (this.s3 && config.AWS_S3_BUCKET) {
+            await this.s3.send(new DeleteObjectCommand({
+                Bucket: config.AWS_S3_BUCKET,
+                Key: key
+            }));
+            return;
+        }
+        rmSync(this.resolveLocalPath(key), { force: true });
+    }
+    resolveLocalPath(key) {
+        const normalizedKey = normalizeStorageKey(key);
+        const root = path.resolve(this.localRoot);
+        const filePath = path.resolve(root, normalizedKey);
+        if (filePath !== root && !filePath.startsWith(`${root}${path.sep}`)) {
+            throw new Error("Invalid storage key.");
+        }
+        return filePath;
+    }
+    async createReadUrl(key) {
+        if (this.s3 && config.AWS_S3_BUCKET) {
+            const command = new GetObjectCommand({
+                Bucket: config.AWS_S3_BUCKET,
+                Key: key
+            });
+            return getSignedUrl(this.s3, command, { expiresIn: 86400 });
+        }
+        return this.getPublicUrl(key);
+    }
+}
+export function joinStorageKey(...parts) {
+    return parts
+        .flatMap((part) => part.split("/"))
+        .map((part) => part.trim())
+        .filter(Boolean)
+        .join("/");
+}
+function normalizeStorageKey(key) {
+    const normalized = key.replace(/^\/+/, "");
+    if (!normalized ||
+        normalized.includes("\\") ||
+        path.isAbsolute(normalized) ||
+        normalized.split("/").some((segment) => !segment || segment === "." || segment === "..")) {
+        throw new Error("Invalid storage key.");
+    }
+    return normalized;
+}
+// MUST match the bucket resource policy in the CDK stacks. Adding a prefix
+// here without also granting it public read in the S3 bucket policy will
+// produce 403s for anonymous readers. Kept alphabetized for grepability.
+function isPublicStorageKey(key) {
+    return [
+        "assets/channels/",
+        "compositions/forks/",
+        "developer/",
+        "primitives/",
+        "templates/",
+        "user/",
+        "users/"
+    ].some((prefix) => key.startsWith(prefix));
+}
+function inferContentType(filePath) {
+    switch (path.extname(filePath).toLowerCase()) {
+        case ".json":
+            return "application/json";
+        case ".png":
+            return "image/png";
+        case ".gif":
+            return "image/gif";
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".webp":
+            return "image/webp";
+        case ".svg":
+            return "image/svg+xml";
+        case ".mp4":
+            return "video/mp4";
+        case ".webm":
+            return "video/webm";
+        case ".mov":
+            return "video/quicktime";
+        case ".mp3":
+            return "audio/mpeg";
+        case ".wav":
+            return "audio/wav";
+        case ".m4a":
+            return "audio/mp4";
+        case ".ogg":
+            return "audio/ogg";
+        case ".pdf":
+            return "application/pdf";
+        case ".md":
+            return "text/markdown; charset=utf-8";
+        case ".txt":
+            return "text/plain; charset=utf-8";
+        default:
+            return "application/octet-stream";
+    }
+}
+function walkLocalTree(root, onFile) {
+    try {
+        const entries = readdirSync(root, { withFileTypes: true });
+        for (const entry of entries) {
+            const childPath = path.join(root, entry.name);
+            if (entry.isDirectory()) {
+                walkLocalTree(childPath, onFile);
+            }
+            else if (entry.isFile()) {
+                onFile(childPath);
+            }
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+}
+//# sourceMappingURL=storage.js.map