@vryzel/file-next 0.4.0

package/dist/server/index.cjs

@@ -0,0 +1,628 @@
+'use strict';
+
+require('server-only');
+var zod = require('zod');
+
+// src/server/entry.ts
+
+// src/types/result.ts
+var ok = (value) => ({ ok: true, value });
+var err = (error) => ({ ok: false, error });
+
+// src/errors/mappers.ts
+var HTTP_STATUS_TO_CODE = {
+  401: { code: "Unauthorized", retryable: false },
+  403: { code: "Forbidden", retryable: false },
+  404: { code: "NotFound", retryable: false },
+  408: { code: "NetworkError", retryable: true },
+  409: { code: "Conflict", retryable: false },
+  413: { code: "PayloadTooLarge", retryable: false },
+  415: { code: "UnsupportedMediaType", retryable: false },
+  429: { code: "RateLimited", retryable: true }
+};
+var AWS_NAME_TO_CODE = {
+  NoSuchKey: { code: "NotFound", retryable: false },
+  NoSuchBucket: { code: "NotFound", retryable: false },
+  // v0.2 multipart: unknown/aborted/expired uploadId.
+  NoSuchUpload: { code: "NotFound", retryable: false },
+  AccessDenied: { code: "Forbidden", retryable: false },
+  SlowDown: { code: "QuotaExceeded", retryable: true },
+  BadDigest: { code: "ChecksumMismatch", retryable: true },
+  XAmzContentSHA256Mismatch: { code: "ChecksumMismatch", retryable: true },
+  NetworkingError: { code: "NetworkError", retryable: true },
+  TimeoutError: { code: "NetworkError", retryable: true }
+};
+var PG_SQLSTATE_TO_CODE = {
+  "23505": { code: "Conflict", retryable: false }
+};
+var SQLITE_CODE_TO_CODE = {
+  SQLITE_CONSTRAINT_UNIQUE: { code: "Conflict", retryable: false },
+  SQLITE_CONSTRAINT_PRIMARYKEY: { code: "Conflict", retryable: false }
+};
+var toCause = (code, message, extra) => ({
+  code,
+  message,
+  ...extra ?? {}
+});
+var fallback = (err2) => new FileSystemError({
+  code: "InternalError",
+  message: err2 instanceof Error ? err2.message : String(err2),
+  retryable: true,
+  cause: toCause(
+    "Unknown",
+    err2 instanceof Error ? err2.message : String(err2)
+  )
+});
+var fromAws = (err2) => {
+  if (err2 instanceof FileSystemError) return err2;
+  if (typeof err2 !== "object" || err2 === null) return fallback(err2);
+  const awsErr = err2;
+  const name = typeof awsErr.name === "string" ? awsErr.name : void 0;
+  const message = typeof awsErr.message === "string" ? awsErr.message : `AWS error: ${name ?? "unknown"}`;
+  const status = typeof awsErr.$metadata?.httpStatusCode === "number" ? awsErr.$metadata.httpStatusCode : void 0;
+  const cause = toCause(
+    name ?? (status !== void 0 ? String(status) : "Unknown"),
+    message,
+    status !== void 0 ? { httpStatusCode: status } : void 0
+  );
+  if (name && name in AWS_NAME_TO_CODE) {
+    const m = AWS_NAME_TO_CODE[name];
+    return new FileSystemError({ code: m.code, message, retryable: m.retryable, cause });
+  }
+  if (status !== void 0 && status in HTTP_STATUS_TO_CODE) {
+    const m = HTTP_STATUS_TO_CODE[status];
+    return new FileSystemError({ code: m.code, message, retryable: m.retryable, cause });
+  }
+  if (status !== void 0 && status >= 500 && status < 600) {
+    return new FileSystemError({ code: "InternalError", message, retryable: true, cause });
+  }
+  if (status !== void 0 && status >= 400 && status < 500) {
+    return new FileSystemError({ code: "Forbidden", message, retryable: false, cause });
+  }
+  return new FileSystemError({ code: "InternalError", message, retryable: true, cause });
+};
+var fromPg = (err2) => {
+  if (err2 instanceof FileSystemError) return err2;
+  if (typeof err2 !== "object" || err2 === null) return fallback(err2);
+  const pgErr = err2;
+  const sqlstate = typeof pgErr.code === "string" ? pgErr.code : void 0;
+  const message = typeof pgErr.message === "string" ? pgErr.message : `Postgres error: ${sqlstate ?? "unknown"}`;
+  const cause = toCause(sqlstate ?? "Unknown", message);
+  if (sqlstate && sqlstate in PG_SQLSTATE_TO_CODE) {
+    const m = PG_SQLSTATE_TO_CODE[sqlstate];
+    return new FileSystemError({ code: m.code, message, retryable: m.retryable, cause });
+  }
+  return new FileSystemError({ code: "InternalError", message, retryable: true, cause });
+};
+var fromSqlite = (err2) => {
+  if (err2 instanceof FileSystemError) return err2;
+  if (typeof err2 !== "object" || err2 === null) return fallback(err2);
+  const sqlErr = err2;
+  const code = typeof sqlErr.code === "string" ? sqlErr.code : void 0;
+  const message = typeof sqlErr.message === "string" ? sqlErr.message : `SQLite error: ${code ?? "unknown"}`;
+  const cause = toCause(code ?? "Unknown", message);
+  if (code && code in SQLITE_CODE_TO_CODE) {
+    const m = SQLITE_CODE_TO_CODE[code];
+    return new FileSystemError({ code: m.code, message, retryable: m.retryable, cause });
+  }
+  return new FileSystemError({ code: "InternalError", message, retryable: true, cause });
+};
+
+// src/errors/index.ts
+var FileSystemError = class extends Error {
+  code;
+  retryable;
+  cause;
+  constructor(opts) {
+    super(opts.message);
+    this.name = "FileSystemError";
+    this.code = opts.code;
+    this.retryable = opts.retryable;
+    if (opts.cause !== void 0) {
+      this.cause = opts.cause;
+    }
+  }
+  /**
+   * Stable JSON shape for RSC pass-through. Error.prototype.message
+   * is non-enumerable, so plain `JSON.stringify(err)` would emit `{}`
+   * and lose the message + code + retryable flag. `cause` is omitted
+   * entirely (not set to undefined) when absent so the shape stays
+   * stable for hash-based caches.
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      retryable: this.retryable,
+      ...this.cause !== void 0 ? { cause: this.cause } : {}
+    };
+  }
+  /**
+   * Mappers from upstream error shapes (AWS SDK v3, node-postgres,
+   * better-sqlite3) to FileSystemError. See `./mappers.ts` for the
+   * mapping tables. Re-exposed as static methods so callers can pick
+   * the import style that fits; the free functions are the canonical
+   * implementation.
+   */
+  static fromAws(err2) {
+    return fromAws(err2);
+  }
+  static fromPg(err2) {
+    return fromPg(err2);
+  }
+  static fromSqlite(err2) {
+    return fromSqlite(err2);
+  }
+};
+
+// src/types/branded.ts
+var asS3Key = (s) => s;
+var asTenantId = (s) => s;
+
+// src/server/actions.ts
+var NodeIdSchema = zod.z.string().min(1, "id is required");
+var PathSchema = zod.z.string().nullable();
+var ListFilesInputSchema = zod.z.object({
+  parentId: PathSchema,
+  limit: zod.z.number().int().positive().optional(),
+  cursor: zod.z.string().optional()
+});
+var DeleteFileInputSchema = zod.z.object({
+  id: NodeIdSchema,
+  recursive: zod.z.boolean().optional()
+});
+var MoveFileInputSchema = zod.z.object({
+  id: NodeIdSchema,
+  newParentId: PathSchema,
+  newName: zod.z.string().min(1).max(255).optional()
+});
+var CopyFileInputSchema = zod.z.object({
+  id: NodeIdSchema,
+  newParentId: PathSchema,
+  newName: zod.z.string().min(1).max(255).optional()
+});
+var SetMetadataInputSchema = zod.z.object({
+  id: NodeIdSchema,
+  metadata: zod.z.record(zod.z.string()),
+  replace: zod.z.boolean().optional()
+});
+var CreateFolderInputSchema = zod.z.object({
+  parentId: PathSchema,
+  name: zod.z.string().min(1).max(255)
+});
+var PrepareUploadInputSchema = zod.z.object({
+  parentId: PathSchema,
+  name: zod.z.string().min(1).max(255),
+  contentType: zod.z.string().min(1),
+  contentLength: zod.z.number().int().nonnegative()
+});
+var ConfirmUploadInputSchema = zod.z.object({
+  id: NodeIdSchema,
+  parentId: PathSchema,
+  name: zod.z.string().min(1).max(255),
+  contentType: zod.z.string().optional(),
+  size: zod.z.number().int().nonnegative().optional()
+});
+var SearchFilesInputSchema = zod.z.object({
+  query: zod.z.string(),
+  parentId: zod.z.string().optional(),
+  limit: zod.z.number().int().positive().optional()
+});
+var RestoreNodeInputSchema = zod.z.object({
+  id: NodeIdSchema
+});
+var CreateShareInputSchema = zod.z.object({
+  id: NodeIdSchema
+});
+var ResolveShareInputSchema = zod.z.object({
+  token: zod.z.string().min(1)
+});
+var RevokeShareInputSchema = zod.z.object({
+  token: zod.z.string().min(1)
+});
+var zodErr = (message, parsed) => err(
+  new FileSystemError({
+    code: "InternalError",
+    message,
+    retryable: false,
+    cause: { code: "ZodError", message: parsed.error.message, issues: parsed.error.issues }
+  })
+);
+var createServerActions = (deps) => {
+  const { store, writeThrough, fs, getAuth } = deps;
+  const wrap = (e, code, message) => {
+    if (e instanceof FileSystemError) return e;
+    return new FileSystemError({
+      code,
+      message: `${message}: ${e instanceof Error ? e.message : String(e)}`,
+      retryable: true
+    });
+  };
+  const authTenant = async () => getAuth();
+  const listFiles = async (input) => {
+    const parsed = ListFilesInputSchema.safeParse(input);
+    if (!parsed.success) return zodErr("Invalid listFiles input", parsed);
+    try {
+      const auth = await authTenant();
+      return store.listChildren({
+        tenantId: asTenantId(auth.tenantId),
+        parentId: parsed.data.parentId,
+        limit: parsed.data.limit,
+        cursor: parsed.data.cursor
+      });
+    } catch (e) {
+      return err(wrap(e, "InternalError", "listFiles failed"));
+    }
+  };
+  const deleteFile = async (input) => {
+    const parsed = DeleteFileInputSchema.safeParse(input);
+    if (!parsed.success) return zodErr("Invalid deleteFile input", parsed);
+    try {
+      const auth = await authTenant();
+      return writeThrough.deleteThroughFile({
+        tenantId: auth.tenantId,
+        id: parsed.data.id,
+        recursive: parsed.data.recursive
+      });
+    } catch (e) {
+      return err(wrap(e, "InternalError", "deleteFile failed"));
+    }
+  };
+  const moveFile = async (input) => {
+    const parsed = MoveFileInputSchema.safeParse(input);
+    if (!parsed.success) return zodErr("Invalid moveFile input", parsed);
+    try {
+      const auth = await authTenant();
+      return store.moveNode({
+        tenantId: asTenantId(auth.tenantId),
+        id: parsed.data.id,
+        newParentId: parsed.data.newParentId,
+        newName: parsed.data.newName
+      });
+    } catch (e) {
+      return err(wrap(e, "InternalError", "moveFile failed"));
+    }
+  };
+  const copyFile = async (input) => {
+    const parsed = CopyFileInputSchema.safeParse(input);
+    if (!parsed.success) return zodErr("Invalid copyFile input", parsed);
+    try {
+      const auth = await authTenant();
+      return writeThrough.copyThroughFile({
+        tenantId: auth.tenantId,
+        id: parsed.data.id,
+        newParentId: parsed.data.newParentId,
+        newName: parsed.data.newName
+      });
+    } catch (e) {
+      return err(wrap(e, "InternalError", "copyFile failed"));
+    }
+  };
+  const setMetadata = async (input) => {
+    const parsed = SetMetadataInputSchema.safeParse(input);
+    if (!parsed.success) return zodErr("Invalid setMetadata input", parsed);
+    try {
+      const auth = await authTenant();
+      return store.updateMetadata({
+        tenantId: asTenantId(auth.tenantId),
+        id: parsed.data.id,
+        metadata: parsed.data.metadata,
+        replace: parsed.data.replace
+      });
+    } catch (e) {
+      return err(wrap(e, "InternalError", "setMetadata failed"));
+    }
+  };
+  const createFolder = async (input) => {
+    const parsed = CreateFolderInputSchema.safeParse(input);
+    if (!parsed.success) return zodErr("Invalid createFolder input", parsed);
+    try {
+      const auth = await authTenant();
+      return store.createNode({
+        tenantId: asTenantId(auth.tenantId),
+        parentId: parsed.data.parentId,
+        name: parsed.data.name,
+        kind: "folder",
+        size: 0,
+        mimeType: "",
+        s3Key: "",
+        ownerId: auth.userId
+      });
+    } catch (e) {
+      return err(wrap(e, "InternalError", "createFolder failed"));
+    }
+  };
+  const prepareUpload = async (input) => {
+    const parsed = PrepareUploadInputSchema.safeParse(input);
+    if (!parsed.success) return zodErr("Invalid prepareUpload input", parsed);
+    try {
+      const auth = await authTenant();
+      const id = typeof globalThis.crypto?.randomUUID === "function" ? globalThis.crypto.randomUUID() : `upl-${Date.now()}`;
+      const signed = await fs.forTenant(auth.tenantId).adapter.createPresignedUploadUrl({
+        key: asS3Key(id),
+        contentType: parsed.data.contentType,
+        expiresIn: 900
+      });
+      if (!signed.ok) return signed;
+      return ok({
+        id,
+        key: id,
+        url: signed.value.url,
+        method: signed.value.method,
+        headers: signed.value.requiredHeaders ?? {},
+        expiresAt: new Date(Date.now() + 9e5).toISOString()
+      });
+    } catch (e) {
+      return err(wrap(e, "InternalError", "prepareUpload failed"));
+    }
+  };
+  const confirmUpload = async (input) => {
+    const parsed = ConfirmUploadInputSchema.safeParse(input);
+    if (!parsed.success) return zodErr("Invalid confirmUpload input", parsed);
+    try {
+      const auth = await authTenant();
+      return writeThrough.confirmUpload({
+        tenantId: auth.tenantId,
+        id: parsed.data.id,
+        parentId: parsed.data.parentId,
+        name: parsed.data.name,
+        contentType: parsed.data.contentType,
+        size: parsed.data.size,
+        ownerId: auth.userId
+      });
+    } catch (e) {
+      return err(wrap(e, "InternalError", "confirmUpload failed"));
+    }
+  };
+  const searchFiles = async (input) => {
+    const parsed = SearchFilesInputSchema.safeParse(input);
+    if (!parsed.success) return zodErr("Invalid searchFiles input", parsed);
+    try {
+      const auth = await authTenant();
+      return store.search({
+        tenantId: asTenantId(auth.tenantId),
+        query: parsed.data.query,
+        parentId: parsed.data.parentId,
+        limit: parsed.data.limit
+      });
+    } catch (e) {
+      return err(wrap(e, "InternalError", "searchFiles failed"));
+    }
+  };
+  const listTrash = async (input = {}) => {
+    try {
+      const auth = await authTenant();
+      return store.listTrash({
+        tenantId: asTenantId(auth.tenantId),
+        limit: input.limit,
+        cursor: input.cursor
+      });
+    } catch (e) {
+      return err(wrap(e, "InternalError", "listTrash failed"));
+    }
+  };
+  const restoreNode = async (input) => {
+    const parsed = RestoreNodeInputSchema.safeParse(input);
+    if (!parsed.success) return zodErr("Invalid restoreNode input", parsed);
+    try {
+      const auth = await authTenant();
+      return store.restoreNode({
+        tenantId: asTenantId(auth.tenantId),
+        id: parsed.data.id
+      });
+    } catch (e) {
+      return err(wrap(e, "InternalError", "restoreNode failed"));
+    }
+  };
+  const createShare = async (input) => {
+    const parsed = CreateShareInputSchema.safeParse(input);
+    if (!parsed.success) return zodErr("Invalid createShare input", parsed);
+    try {
+      const auth = await authTenant();
+      return store.createShare({
+        tenantId: asTenantId(auth.tenantId),
+        nodeId: parsed.data.id
+      });
+    } catch (e) {
+      return err(wrap(e, "InternalError", "createShare failed"));
+    }
+  };
+  const resolveShare = async (input) => {
+    const parsed = ResolveShareInputSchema.safeParse(input);
+    if (!parsed.success) return zodErr("Invalid resolveShare input", parsed);
+    try {
+      return store.resolveShare({ token: parsed.data.token });
+    } catch (e) {
+      return err(wrap(e, "InternalError", "resolveShare failed"));
+    }
+  };
+  const revokeShare = async (input) => {
+    const parsed = RevokeShareInputSchema.safeParse(input);
+    if (!parsed.success) return zodErr("Invalid revokeShare input", parsed);
+    try {
+      const auth = await authTenant();
+      return store.revokeShare({
+        tenantId: asTenantId(auth.tenantId),
+        token: parsed.data.token
+      });
+    } catch (e) {
+      return err(wrap(e, "InternalError", "revokeShare failed"));
+    }
+  };
+  return {
+    listFiles,
+    deleteFile,
+    moveFile,
+    copyFile,
+    setMetadata,
+    createFolder,
+    prepareUpload,
+    confirmUpload,
+    searchFiles,
+    listTrash,
+    restoreNode,
+    createShare,
+    resolveShare,
+    revokeShare
+  };
+};
+
+// src/server/route-handlers/upload.ts
+var MAX_EXPIRES_IN_SECONDS = 7 * 24 * 60 * 60;
+var DEFAULT_EXPIRES_IN_SECONDS = 900;
+var matchesContentType = (pattern, actual) => {
+  if (pattern === actual) return true;
+  if (pattern.endsWith("/*")) {
+    const prefix = pattern.slice(0, -1);
+    return actual.startsWith(prefix);
+  }
+  return false;
+};
+var assertExpiresIn = (expiresIn) => {
+  if (!Number.isFinite(expiresIn) || expiresIn < 1 || expiresIn > MAX_EXPIRES_IN_SECONDS) {
+    throw new FileSystemError({
+      code: "InternalError",
+      message: `expiresIn must be between 1 and ${MAX_EXPIRES_IN_SECONDS} seconds (S3 SigV4 limit)`,
+      retryable: false,
+      cause: { code: "InvalidArgument", message: `expiresIn=${expiresIn}` }
+    });
+  }
+};
+var createUploadRouteHandler = (opts) => {
+  const expiresIn = opts.expiresIn ?? DEFAULT_EXPIRES_IN_SECONDS;
+  assertExpiresIn(expiresIn);
+  return async (req) => {
+    let body;
+    try {
+      body = await req.json();
+    } catch {
+      return Response.json(
+        { ok: false, error: { code: "InternalError", message: "Request body must be valid JSON" } },
+        { status: 400 }
+      );
+    }
+    if (typeof opts.maxBytes === "number" && body.contentLength > opts.maxBytes) {
+      return Response.json(
+        {
+          ok: false,
+          error: {
+            code: "PayloadTooLarge",
+            message: `contentLength ${body.contentLength} exceeds maxBytes ${opts.maxBytes}`
+          }
+        },
+        { status: 413 }
+      );
+    }
+    if (opts.allowedContentTypes && opts.allowedContentTypes.length > 0) {
+      const allowed = opts.allowedContentTypes.some((p) => matchesContentType(p, body.contentType));
+      if (!allowed) {
+        return Response.json(
+          {
+            ok: false,
+            error: {
+              code: "UnsupportedMediaType",
+              message: `contentType "${body.contentType}" is not in the allowed list`
+            }
+          },
+          { status: 415 }
+        );
+      }
+    }
+    let fs = opts.fs;
+    if (opts.getAuth) {
+      const auth = await opts.getAuth(req);
+      if (!auth) {
+        return Response.json(
+          { ok: false, error: { code: "Unauthorized", message: "Not authenticated" } },
+          { status: 401 }
+        );
+      }
+      fs = opts.fs.forTenant(auth.tenantId);
+    }
+    const id = typeof globalThis.crypto?.randomUUID === "function" ? globalThis.crypto.randomUUID() : `upl-${Date.now()}`;
+    const r = await fs.adapter.createPresignedUploadUrl({
+      key: asS3Key(id),
+      contentType: body.contentType,
+      expiresIn
+    });
+    if (!r.ok) {
+      return Response.json(
+        { ok: false, error: { code: r.error.code, message: r.error.message } },
+        { status: 500 }
+      );
+    }
+    const expiresAt = new Date(Date.now() + expiresIn * 1e3).toISOString();
+    return Response.json({
+      ok: true,
+      value: {
+        url: r.value.url,
+        key: id,
+        id,
+        method: r.value.method,
+        headers: r.value.requiredHeaders ?? {},
+        expiresAt
+      }
+    });
+  };
+};
+
+// src/server/route-handlers/download.ts
+var MAX_EXPIRES_IN_SECONDS2 = 7 * 24 * 60 * 60;
+var DEFAULT_EXPIRES_IN_SECONDS2 = 900;
+var assertExpiresIn2 = (expiresIn) => {
+  if (!Number.isFinite(expiresIn) || expiresIn < 1 || expiresIn > MAX_EXPIRES_IN_SECONDS2) {
+    throw new FileSystemError({
+      code: "InternalError",
+      message: `expiresIn must be between 1 and ${MAX_EXPIRES_IN_SECONDS2} seconds (S3 SigV4 limit)`,
+      retryable: false,
+      cause: { code: "InvalidArgument", message: `expiresIn=${expiresIn}` }
+    });
+  }
+};
+var createDownloadRouteHandler = (opts) => {
+  const expiresIn = opts.expiresIn ?? DEFAULT_EXPIRES_IN_SECONDS2;
+  assertExpiresIn2(expiresIn);
+  return async (req) => {
+    const url = new URL(req.url);
+    const key = url.searchParams.get("key");
+    if (!key) {
+      return Response.json(
+        { ok: false, error: { code: "InternalError", message: "Missing required query param: key" } },
+        { status: 400 }
+      );
+    }
+    let fs = opts.fs;
+    if (opts.getAuth) {
+      const auth = await opts.getAuth(req);
+      if (!auth) {
+        return Response.json(
+          { ok: false, error: { code: "Unauthorized", message: "Not authenticated" } },
+          { status: 401 }
+        );
+      }
+      fs = opts.fs.forTenant(auth.tenantId);
+    }
+    const r = await fs.adapter.createPresignedDownloadUrl({
+      key: asS3Key(key),
+      expiresIn
+    });
+    if (!r.ok) {
+      return Response.json(
+        { ok: false, error: { code: r.error.code, message: r.error.message } },
+        { status: 500 }
+      );
+    }
+    const expiresAt = new Date(Date.now() + expiresIn * 1e3).toISOString();
+    return Response.json({
+      ok: true,
+      value: { url: r.value.url, expiresAt }
+    });
+  };
+};
+
+exports.createDownloadRouteHandler = createDownloadRouteHandler;
+exports.createServerActions = createServerActions;
+exports.createUploadRouteHandler = createUploadRouteHandler;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map