s3kit 0.1.0 → 0.1.1

package/dist/adapters/next.js

@@ -6,6 +6,7 @@ import {
   CopyObjectCommand,
   DeleteObjectCommand,
   DeleteObjectsCommand,
+  HeadObjectCommand,
   ListObjectsV2Command,
   PutObjectCommand
 } from "@aws-sdk/client-s3";
@@ -22,6 +23,15 @@ var S3FileManagerAuthorizationError = class extends Error {
     this.code = code;
   }
 };
+var S3FileManagerConflictError = class extends Error {
+  status;
+  code;
+  constructor(message, status = 409, code = "conflict") {
+    super(message);
+    this.status = status;
+    this.code = code;
+  }
+};
 
 // src/core/manager.ts
 var DEFAULT_DELIMITER = "/";
@@ -54,6 +64,60 @@ function isNoSuchKeyError(err) {
   }
   return false;
 }
+function isNotFoundError(err) {
+  if (!err || typeof err !== "object") return false;
+  if ("name" in err && (err.name === "NotFound" || err.name === "NoSuchKey")) return true;
+  if ("$metadata" in err) {
+    const meta = err.$metadata;
+    if (meta?.httpStatusCode === 404) return true;
+  }
+  return false;
+}
+function isPreconditionFailedError(err) {
+  if (!err || typeof err !== "object") return false;
+  if ("name" in err && err.name === "PreconditionFailed") return true;
+  if ("Code" in err && err.Code === "PreconditionFailed") return true;
+  if ("$metadata" in err) {
+    const meta = err.$metadata;
+    if (meta?.httpStatusCode === 412) return true;
+  }
+  if ("message" in err && typeof err.message === "string") {
+    return err.message.includes("PreconditionFailed");
+  }
+  return false;
+}
+function resolveExpiresAt(expiresAt) {
+  if (expiresAt === null) return void 0;
+  if (!expiresAt) return void 0;
+  const parsed = new Date(expiresAt);
+  if (!Number.isFinite(parsed.getTime())) {
+    throw new Error("Invalid expiresAt value");
+  }
+  return parsed;
+}
+function toAttributes(path, obj) {
+  const {
+    ContentLength,
+    LastModified,
+    ETag,
+    ContentType,
+    CacheControl,
+    ContentDisposition,
+    Metadata,
+    Expires
+  } = obj;
+  return {
+    path,
+    ...ContentLength !== void 0 ? { size: ContentLength } : {},
+    ...LastModified ? { lastModified: LastModified.toISOString() } : {},
+    ...ETag !== void 0 ? { etag: ETag } : {},
+    ...ContentType ? { contentType: ContentType } : {},
+    ...CacheControl ? { cacheControl: CacheControl } : {},
+    ...ContentDisposition ? { contentDisposition: ContentDisposition } : {},
+    ...Metadata ? { metadata: Metadata } : {},
+    ...Expires ? { expiresAt: Expires.toISOString() } : {}
+  };
+}
 async function* listAllKeys(s3, bucket, prefix) {
   let cursor;
   while (true) {
@@ -93,6 +157,9 @@ var S3FileManager = class {
   delimiter;
   hooks;
   authorizationMode;
+  lockFolderMoves;
+  lockPrefix;
+  lockTtlSeconds;
   constructor(s3, options) {
     this.s3 = s3;
     this.bucket = options.bucket;
@@ -100,6 +167,9 @@ var S3FileManager = class {
     this.rootPrefix = ensureTrailingDelimiter(trimSlashes(options.rootPrefix ?? ""), this.delimiter);
     this.hooks = options.hooks;
     this.authorizationMode = options.authorizationMode ?? "deny-by-default";
+    this.lockFolderMoves = options.lockFolderMoves ?? true;
+    this.lockPrefix = options.lockPrefix ?? ".s3kit/locks";
+    this.lockTtlSeconds = options.lockTtlSeconds ?? 60 * 15;
   }
   async authorize(args) {
     const hasAuthHooks = Boolean(this.hooks?.authorize || this.hooks?.allowAction);
@@ -133,6 +203,87 @@ var S3FileManager = class {
     }
     return key.slice(this.rootPrefix.length);
   }
+  lockKeyForPath(path) {
+    const safe = encodeURIComponent(path).replace(/%2F/g, "__");
+    const prefix = ensureTrailingDelimiter(trimSlashes(this.lockPrefix), this.delimiter);
+    return `${this.rootPrefix}${prefix}${safe}.json`;
+  }
+  async readFolderLockByKey(key) {
+    try {
+      const out = await this.s3.send(
+        new HeadObjectCommand({
+          Bucket: this.bucket,
+          Key: key
+        })
+      );
+      const meta = out.Metadata ?? {};
+      const operation = meta.op === "folder.move" ? "folder.move" : void 0;
+      const fromPath = meta.from;
+      const toPath = meta.to;
+      const startedAt = meta.startedat;
+      const expiresAt = meta.expiresat ?? (out.Expires ? out.Expires.toISOString() : void 0);
+      if (!operation || !fromPath || !toPath || !startedAt || !expiresAt) return null;
+      return {
+        path: fromPath,
+        operation,
+        fromPath,
+        toPath,
+        startedAt,
+        expiresAt,
+        ...meta.owner ? { owner: meta.owner } : {}
+      };
+    } catch (err) {
+      if (isNotFoundError(err)) return null;
+      throw err;
+    }
+  }
+  async acquireFolderMoveLock(fromPath, toPath, ctx) {
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const expiresAt = new Date(Date.now() + this.lockTtlSeconds * 1e3).toISOString();
+    const key = this.lockKeyForPath(fromPath);
+    const writeLock = async () => {
+      await this.s3.send(
+        new PutObjectCommand({
+          Bucket: this.bucket,
+          Key: key,
+          ContentType: "application/json",
+          Expires: new Date(expiresAt),
+          Metadata: {
+            op: "folder.move",
+            from: fromPath,
+            to: toPath,
+            startedat: startedAt,
+            expiresat: expiresAt,
+            ...ctx.userId ? { owner: String(ctx.userId) } : {}
+          },
+          IfNoneMatch: "*",
+          Body: ""
+        })
+      );
+    };
+    try {
+      await writeLock();
+      return key;
+    } catch (err) {
+      if (!isPreconditionFailedError(err)) throw err;
+      const existing = await this.readFolderLockByKey(key);
+      if (existing?.expiresAt) {
+        const exp = new Date(existing.expiresAt);
+        if (Number.isFinite(exp.getTime()) && exp.getTime() <= Date.now()) {
+          await this.s3.send(new DeleteObjectCommand({ Bucket: this.bucket, Key: key }));
+          await writeLock();
+          return key;
+        }
+      }
+      throw new S3FileManagerConflictError("Folder rename already in progress");
+    }
+  }
+  async releaseFolderMoveLock(key) {
+    try {
+      await this.s3.send(new DeleteObjectCommand({ Bucket: this.bucket, Key: key }));
+    } catch {
+    }
+  }
   makeFolderEntry(path) {
     const p = normalizePath(path);
     const name = p === "" ? "" : p.split("/").at(-1) ?? "";
@@ -234,12 +385,39 @@ var S3FileManager = class {
     await deleteKeysInBatches(this.s3, this.bucket, keys);
   }
   async deleteFiles(options, ctx = {}) {
-    const paths = options.paths.map((p) => normalizePath(p));
-    for (const path of paths) {
-      await this.authorize({ action: "file.delete", path, ctx });
+    const items = options.items ?? options.paths?.map((path) => ({ path }));
+    if (!items || items.length === 0) return;
+    const normalizedItems = items.map((item) => ({
+      path: normalizePath(item.path),
+      ifMatch: item.ifMatch,
+      ifNoneMatch: item.ifNoneMatch
+    }));
+    for (const item of normalizedItems) {
+      await this.authorize({ action: "file.delete", path: item.path, ctx });
+    }
+    const hasConditions = normalizedItems.some((item) => item.ifMatch || item.ifNoneMatch);
+    if (!hasConditions) {
+      const keys = normalizedItems.map((item) => this.pathToKey(item.path));
+      await deleteKeysInBatches(this.s3, this.bucket, keys);
+      return;
+    }
+    for (const item of normalizedItems) {
+      try {
+        await this.s3.send(
+          new DeleteObjectCommand({
+            Bucket: this.bucket,
+            Key: this.pathToKey(item.path),
+            ...item.ifMatch ? { IfMatch: item.ifMatch } : {},
+            ...item.ifNoneMatch ? { IfNoneMatch: item.ifNoneMatch } : {}
+          })
+        );
+      } catch (err) {
+        if (isPreconditionFailedError(err)) {
+          throw new S3FileManagerConflictError("Delete conflict");
+        }
+        throw err;
+      }
     }
-    const keys = paths.map((p) => this.pathToKey(p));
-    await deleteKeysInBatches(this.s3, this.bucket, keys);
   }
   async copy(options, ctx = {}) {
     const isFolder = options.fromPath.endsWith(this.delimiter);
@@ -289,13 +467,21 @@ var S3FileManager = class {
     await this.authorize({ action: "file.copy", fromPath, toPath, ctx });
     const fromKey = this.pathToKey(fromPath);
     const toKey = this.pathToKey(toPath);
-    await this.s3.send(
-      new CopyObjectCommand({
-        Bucket: this.bucket,
-        Key: toKey,
-        CopySource: encodeS3CopySource(this.bucket, fromKey)
-      })
-    );
+    try {
+      await this.s3.send(
+        new CopyObjectCommand({
+          Bucket: this.bucket,
+          Key: toKey,
+          CopySource: encodeS3CopySource(this.bucket, fromKey),
+          ...options.ifMatch ? { CopySourceIfMatch: options.ifMatch } : {}
+        })
+      );
+    } catch (err) {
+      if (isPreconditionFailedError(err)) {
+        throw new S3FileManagerConflictError("Copy conflict");
+      }
+      throw err;
+    }
   }
   async move(options, ctx = {}) {
     const isFolder = options.fromPath.endsWith(this.delimiter);
@@ -305,19 +491,49 @@ var S3FileManager = class {
     if (isFolder) {
       const fromPathWithSlash = ensureTrailingDelimiter(fromPath, this.delimiter);
       const toPathWithSlash = ensureTrailingDelimiter(toPath, this.delimiter);
+      let lockKey = null;
       await this.authorize({
         action: "folder.move",
         fromPath: fromPathWithSlash,
         toPath: toPathWithSlash,
         ctx
       });
-      await this.copy(options, ctx);
-      await this.deleteFolder({ path: fromPathWithSlash, recursive: true }, ctx);
-      return;
+      try {
+        if (this.lockFolderMoves) {
+          lockKey = await this.acquireFolderMoveLock(fromPathWithSlash, toPathWithSlash, ctx);
+        }
+        await this.copy(options, ctx);
+        await this.deleteFolder({ path: fromPathWithSlash, recursive: true }, ctx);
+        return;
+      } finally {
+        if (lockKey) {
+          await this.releaseFolderMoveLock(lockKey);
+        }
+      }
     }
     await this.authorize({ action: "file.move", fromPath, toPath, ctx });
     await this.copy(options, ctx);
-    await this.deleteFiles({ paths: [fromPath] }, ctx);
+    try {
+      await this.deleteFiles(
+        {
+          items: [
+            {
+              path: fromPath,
+              ...options.ifMatch ? { ifMatch: options.ifMatch } : {}
+            }
+          ]
+        },
+        ctx
+      );
+    } catch (err) {
+      if (err instanceof S3FileManagerConflictError) {
+        try {
+          await this.deleteFiles({ paths: [toPath] }, ctx);
+        } catch {
+        }
+      }
+      throw err;
+    }
   }
   async prepareUploads(options, ctx = {}) {
     const expiresIn = options.expiresInSeconds ?? 60 * 5;
@@ -326,19 +542,24 @@ var S3FileManager = class {
       const path = normalizePath(item.path);
       await this.authorize({ action: "upload.prepare", path, ctx });
       const key = this.pathToKey(path);
+      const expiresAt = resolveExpiresAt(item.expiresAt);
       const cmd = new PutObjectCommand({
         Bucket: this.bucket,
         Key: key,
         ContentType: item.contentType,
         CacheControl: item.cacheControl,
         ContentDisposition: item.contentDisposition,
-        Metadata: item.metadata
+        Metadata: item.metadata,
+        ...expiresAt ? { Expires: expiresAt } : {},
+        ...item.ifNoneMatch ? { IfNoneMatch: item.ifNoneMatch } : {}
       });
       const url = await getSignedUrl(this.s3, cmd, { expiresIn });
       const headers = {};
       if (item.contentType) headers["Content-Type"] = item.contentType;
       if (item.cacheControl) headers["Cache-Control"] = item.cacheControl;
       if (item.contentDisposition) headers["Content-Disposition"] = item.contentDisposition;
+      if (expiresAt) headers.Expires = expiresAt.toUTCString();
+      if (item.ifNoneMatch) headers["If-None-Match"] = item.ifNoneMatch;
       if (item.metadata) {
         for (const [k, v] of Object.entries(item.metadata)) {
           headers[`x-amz-meta-${k}`] = v;
@@ -353,6 +574,59 @@ var S3FileManager = class {
     }
     return result;
   }
+  async getFileAttributes(options, ctx = {}) {
+    const path = normalizePath(options.path);
+    await this.authorize({ action: "file.attributes.get", path, ctx });
+    const key = this.pathToKey(path);
+    const out = await this.s3.send(
+      new HeadObjectCommand({
+        Bucket: this.bucket,
+        Key: key
+      })
+    );
+    return toAttributes(path, out);
+  }
+  async setFileAttributes(options, ctx = {}) {
+    const path = normalizePath(options.path);
+    await this.authorize({ action: "file.attributes.set", path, ctx });
+    const key = this.pathToKey(path);
+    const current = await this.s3.send(
+      new HeadObjectCommand({
+        Bucket: this.bucket,
+        Key: key
+      })
+    );
+    const baseMetadata = options.metadata ?? (current.Metadata ? { ...current.Metadata } : {});
+    const resolvedExpires = options.expiresAt === void 0 ? current.Expires : resolveExpiresAt(options.expiresAt);
+    try {
+      await this.s3.send(
+        new CopyObjectCommand({
+          Bucket: this.bucket,
+          Key: key,
+          CopySource: encodeS3CopySource(this.bucket, key),
+          MetadataDirective: "REPLACE",
+          ContentType: options.contentType ?? current.ContentType,
+          CacheControl: options.cacheControl ?? current.CacheControl,
+          ContentDisposition: options.contentDisposition ?? current.ContentDisposition,
+          Metadata: baseMetadata,
+          ...resolvedExpires ? { Expires: resolvedExpires } : {},
+          ...options.ifMatch ? { CopySourceIfMatch: options.ifMatch } : {}
+        })
+      );
+    } catch (err) {
+      if (isPreconditionFailedError(err)) {
+        throw new S3FileManagerConflictError("Attribute update conflict");
+      }
+      throw err;
+    }
+    const updated = await this.s3.send(
+      new HeadObjectCommand({
+        Bucket: this.bucket,
+        Key: key
+      })
+    );
+    return toAttributes(path, updated);
+  }
   async search(options, ctx = {}) {
     const query = options.query.toLowerCase().trim();
     if (!query) {
@@ -425,6 +699,12 @@ var S3FileManager = class {
     const expiresAt = new Date(Date.now() + expiresIn * 1e3).toISOString();
     return { path, url, expiresAt };
   }
+  async getFolderLock(options, ctx = {}) {
+    const path = ensureTrailingDelimiter(normalizePath(options.path), this.delimiter);
+    await this.authorize({ action: "folder.lock.get", path, ctx });
+    const key = this.lockKeyForPath(path);
+    return await this.readFolderLockByKey(key);
+  }
 };
 
 // src/http/handler.ts
@@ -464,6 +744,21 @@ function optionalString(value, key) {
   if (typeof value === "string") return value;
   throw new S3FileManagerHttpError(400, "invalid_body", `Expected '${key}' to be a string`);
 }
+function optionalStringOrNull(value, key) {
+  if (value === void 0) return void 0;
+  if (value === null) return null;
+  if (typeof value === "string") return value;
+  throw new S3FileManagerHttpError(400, "invalid_body", `Expected '${key}' to be a string`);
+}
+function optionalDateStringOrNull(value, key) {
+  const raw = optionalStringOrNull(value, key);
+  if (raw === void 0 || raw === null) return raw;
+  const parsed = new Date(raw);
+  if (!Number.isFinite(parsed.getTime())) {
+    throw new S3FileManagerHttpError(400, "invalid_body", `Expected '${key}' to be a date string`);
+  }
+  return raw;
+}
 function requiredString(value, key) {
   if (typeof value === "string") return value;
   throw new S3FileManagerHttpError(400, "invalid_body", `Expected '${key}' to be a string`);
@@ -546,13 +841,38 @@ function parseDeleteFolderOptions(body) {
 }
 function parseDeleteFilesOptions(body) {
   const obj = ensureObject(body);
-  return { paths: requiredStringArray(obj.paths, "paths") };
+  const itemsValue = obj.items;
+  const items = Array.isArray(itemsValue) ? itemsValue.map((raw, idx) => {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+      throw new S3FileManagerHttpError(
+        400,
+        "invalid_body",
+        `Expected 'items[${idx}]' to be an object`
+      );
+    }
+    const item = raw;
+    return {
+      path: requiredString(item.path, `items[${idx}].path`),
+      ifMatch: optionalString(item.ifMatch, `items[${idx}].ifMatch`),
+      ifNoneMatch: optionalString(item.ifNoneMatch, `items[${idx}].ifNoneMatch`)
+    };
+  }) : void 0;
+  const paths = obj.paths !== void 0 ? requiredStringArray(obj.paths, "paths") : void 0;
+  if (!paths && !items) {
+    throw new S3FileManagerHttpError(
+      400,
+      "invalid_body",
+      "Expected 'paths' or 'items' to be provided"
+    );
+  }
+  return { ...paths ? { paths } : {}, ...items ? { items } : {} };
 }
 function parseCopyMoveOptions(body) {
   const obj = ensureObject(body);
   return {
     fromPath: requiredString(obj.fromPath, "fromPath"),
-    toPath: requiredString(obj.toPath, "toPath")
+    toPath: requiredString(obj.toPath, "toPath"),
+    ifMatch: optionalString(obj.ifMatch, "ifMatch")
   };
 }
 function parsePrepareUploadsOptions(body) {
@@ -578,7 +898,9 @@ function parsePrepareUploadsOptions(body) {
         item.contentDisposition,
         `items[${idx}].contentDisposition`
       ),
-      metadata: optionalStringRecord(item.metadata, `items[${idx}].metadata`)
+      metadata: optionalStringRecord(item.metadata, `items[${idx}].metadata`),
+      expiresAt: optionalDateStringOrNull(item.expiresAt, `items[${idx}].expiresAt`),
+      ifNoneMatch: optionalString(item.ifNoneMatch, `items[${idx}].ifNoneMatch`)
     };
   });
   return {
@@ -594,6 +916,30 @@ function parsePreviewOptions(body) {
     inline: optionalBoolean(obj.inline, "inline")
   };
 }
+function parseGetFolderLockOptions(body) {
+  const obj = ensureObject(body);
+  return {
+    path: requiredString(obj.path, "path")
+  };
+}
+function parseGetFileAttributesOptions(body) {
+  const obj = ensureObject(body);
+  return {
+    path: requiredString(obj.path, "path")
+  };
+}
+function parseSetFileAttributesOptions(body) {
+  const obj = ensureObject(body);
+  return {
+    path: requiredString(obj.path, "path"),
+    contentType: optionalString(obj.contentType, "contentType"),
+    cacheControl: optionalString(obj.cacheControl, "cacheControl"),
+    contentDisposition: optionalString(obj.contentDisposition, "contentDisposition"),
+    metadata: optionalStringRecord(obj.metadata, "metadata"),
+    expiresAt: optionalDateStringOrNull(obj.expiresAt, "expiresAt"),
+    ifMatch: optionalString(obj.ifMatch, "ifMatch")
+  };
+}
 function createS3FileManagerHttpHandler(options) {
   const basePath = normalizeBasePath(options.api?.basePath);
   if (!options.manager && !options.getManager) {
@@ -641,6 +987,24 @@ function createS3FileManagerHttpHandler(options) {
         const out = await manager.getPreviewUrl(parsePreviewOptions(req.body), ctx);
         return { status: 200, headers: { "content-type": "application/json" }, body: out };
       }
+      if (method === "POST" && path === "/folder/lock/get") {
+        const out = await manager.getFolderLock(parseGetFolderLockOptions(req.body), ctx);
+        return { status: 200, headers: { "content-type": "application/json" }, body: out };
+      }
+      if (method === "POST" && path === "/file/attributes/get") {
+        const out = await manager.getFileAttributes(
+          parseGetFileAttributesOptions(req.body),
+          ctx
+        );
+        return { status: 200, headers: { "content-type": "application/json" }, body: out };
+      }
+      if (method === "POST" && path === "/file/attributes/set") {
+        const out = await manager.setFileAttributes(
+          parseSetFileAttributesOptions(req.body),
+          ctx
+        );
+        return { status: 200, headers: { "content-type": "application/json" }, body: out };
+      }
       return jsonError(404, "not_found", "Route not found");
     } catch (err) {
       if (err instanceof S3FileManagerHttpError) {
@@ -649,6 +1013,9 @@ function createS3FileManagerHttpHandler(options) {
       if (err instanceof S3FileManagerAuthorizationError) {
         return jsonError(err.status, err.code, err.message);
       }
+      if (err instanceof S3FileManagerConflictError) {
+        return jsonError(err.status, err.code, err.message);
+      }
       console.error("[S3FileManager Error]", err);
       const message = err instanceof Error ? err.message : "Unknown error";
       return jsonError(500, "internal_error", message);