target-supabase-sdk 0.2.21 → 0.2.22

package/src/shared/media/node/media.service.ts

@@ -1,6 +1,7 @@
-import { getPossibleTarget, isCreateTargetAlreadyExistsError, postTarget } from "../../../core.api";
-import type { Link } from "../../../link/link.interface";
+import { getPossibleTarget, isCreateTargetAlreadyExistsError, postTarget, updateTarget } from "../../../core.api";
+import { CategoryLink, type Link, type LinkDetails } from "../../../link/link.interface";
 import { createLogger } from "../../log/core/create-logger";
+import { isHttpUrl } from "../../utils/fetch-url";
 import { buildMediaLinkDraft } from "../media.build";
 import { isMediaValue, type MediaValue } from "../media.interface";
 import { mediaLinkDedupFilters } from "../media.query";
@@ -35,6 +36,11 @@ export interface RegisterMediaLinkInput {
     locator: string;
     /** This host id for availability (e.g. `process.env.LOCAL_STORAGE_PROVIDER`). */
     localStorageProvider: string;
+    /**
+     * Local file to probe when `locator` is http(s) (OSS ingest).
+     * Availability uses this path + `localStorageProvider`.
+     */
+    localLocator?: string;
     description?: string;
     tagList?: string[];
 }
@@ -44,9 +50,53 @@ export interface RegisterMediaLinkResult {
     created: boolean;
 }
 
+function mediaOriginalFromRow(row: { details?: unknown }): { storageProvider?: string; locator?: string } {
+    const details = row.details as LinkDetails | undefined;
+    const original = details?.original as { storageProvider?: string; locator?: string } | undefined;
+    return original ?? {};
+}
+
+async function patchMediaOriginal(
+    existing: Link,
+    storageProvider: string,
+    locator: string,
+): Promise<RegisterMediaLinkResult> {
+    const original = mediaOriginalFromRow(existing);
+    if (original.storageProvider === storageProvider && original.locator === locator) {
+        return { id: existing.id, created: false };
+    }
+    await updateTarget({
+        id: existing.id,
+        optimisticLockFilterList: [
+            { field: "category", operator: "eq", value: CategoryLink.LINK },
+            { field: "value", operator: "eq", value: existing.value },
+        ],
+        updateFn: (row) => {
+            const details = row.details as LinkDetails;
+            const prev = (details.original ?? {}) as Record<string, unknown>;
+            return {
+                details: {
+                    ...details,
+                    original: {
+                        ...prev,
+                        storageProvider,
+                        locator,
+                    },
+                },
+            };
+        },
+    });
+    logger.info("media original patched", {
+        topic: "register",
+        data: { id: existing.id, locator },
+    });
+    return { id: existing.id, created: false };
+}
+
 /**
  * Register a media Link: dedup → availability → probe → `postTarget`.
- * Idempotent when `category`+`value`+`name` already exist.
+ * Idempotent when `category`+`value`+`name` already exist (local path).
+ * HTTP `locator` + `localLocator`: probe local file, persist remote URL; patch if name exists.
  *
  * **Node-only** — under `shared/media/node/`; do not import from the browser entry.
  */
@@ -59,19 +109,33 @@ export async function registerMediaLink(input: RegisterMediaLinkInput): Promise<
         throw new Error("registerMediaLink: name is empty");
     }
 
+    const storageProvider = input.storageProvider.trim();
+    const locator = input.locator.trim();
+    const localLocator = input.localLocator?.trim() ?? "";
+    const httpLocator = isHttpUrl(locator);
+
     const existing = await findMediaLink({ value: input.value, name });
-    if (existing != null) {
+    if (existing != null && !httpLocator) {
         logger.info("media already registered", {
             topic: "dedup",
             data: { id: existing.id, value: input.value, name },
         });
         return { id: existing.id, created: false };
     }
+    if (existing != null && httpLocator) {
+        return patchMediaOriginal(existing, storageProvider, locator);
+    }
+
+    const probeStorageProvider = httpLocator ? input.localStorageProvider.trim() : storageProvider;
+    const probeLocator = httpLocator ? localLocator : locator;
+    if (httpLocator && probeLocator === "") {
+        throw new Error("registerMediaLink: localLocator is required when locator is http(s)");
+    }
 
     const availability = await checkMediaAvailability({
         value: input.value,
-        storageProvider: input.storageProvider,
-        locator: input.locator,
+        storageProvider: probeStorageProvider,
+        locator: probeLocator,
         localStorageProvider: input.localStorageProvider,
     });
     if (!availability.ok || availability.absolutePath == null) {
@@ -80,16 +144,16 @@ export async function registerMediaLink(input: RegisterMediaLinkInput): Promise<
 
     const probed = await probeMediaOriginal({
         value: input.value,
-        storageProvider: input.storageProvider,
-        locator: input.locator,
+        storageProvider: probeStorageProvider,
+        locator: probeLocator,
         absolutePath: availability.absolutePath,
     });
 
     const draft = buildMediaLinkDraft({
         value: input.value,
         name,
-        storageProvider: probed.storageProvider,
-        locator: probed.locator,
+        storageProvider: httpLocator ? storageProvider : probed.storageProvider,
+        locator: httpLocator ? locator : probed.locator,
         contentHash: probed.contentHash,
         size: probed.size,
         mimeType: probed.mimeType,
@@ -117,6 +181,9 @@ export async function registerMediaLink(input: RegisterMediaLinkInput): Promise<
         if (isCreateTargetAlreadyExistsError(error)) {
             const raced = await findMediaLink({ value: input.value, name });
             if (raced != null) {
+                if (httpLocator) {
+                    return patchMediaOriginal(raced, storageProvider, locator);
+                }
                 logger.info("media register race — using existing", {
                     topic: "dedup",
                     data: { id: raced.id, value: input.value, name },