naystack 1.1.13-beta.3 → 1.1.13

package/dist/file/put.cjs.js

@@ -0,0 +1,157 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/file/put.ts
+var put_exports = {};
+__export(put_exports, {
+  getFileUploadPutRoute: () => getFileUploadPutRoute
+});
+module.exports = __toCommonJS(put_exports);
+var import_functions2 = require("@vercel/functions");
+var import_server3 = require("next/server");
+var import_uuid = require("uuid");
+
+// src/auth/email/utils.ts
+var import_jsonwebtoken2 = require("jsonwebtoken");
+
+// src/auth/email/token.ts
+var import_bcryptjs = require("bcryptjs");
+var import_jsonwebtoken = require("jsonwebtoken");
+var import_server = require("next/server");
+function getUserIdFromRefreshToken(refreshKey, refreshToken) {
+  if (refreshToken)
+    try {
+      const decoded = (0, import_jsonwebtoken.verify)(refreshToken, refreshKey);
+      if (typeof decoded !== "string" && typeof decoded.id === "number")
+        return decoded.id;
+    } catch (e) {
+      if (!(e instanceof import_jsonwebtoken.JsonWebTokenError)) console.error(e, "errors");
+      return null;
+    }
+  return null;
+}
+
+// src/auth/utils/errors.ts
+var import_server2 = require("next/server");
+
+// src/auth/email/utils.ts
+var getUserContext = (refreshKey, signingKey, req) => {
+  const bearer = req.headers.get("authorization");
+  if (!bearer) {
+    const refresh = req.cookies.get("refresh")?.value;
+    const userId = getUserIdFromRefreshToken(refreshKey, refresh);
+    if (userId) return { refreshUserID: userId };
+    return null;
+  }
+  const token = bearer.slice(7);
+  try {
+    const res = (0, import_jsonwebtoken2.verify)(token, signingKey);
+    if (typeof res === "string") {
+      return null;
+    }
+    return {
+      accessUserId: res.id
+    };
+  } catch {
+  }
+  return null;
+};
+
+// src/file/utils.ts
+var import_node_crypto = require("crypto");
+var import_client_s3 = require("@aws-sdk/client-s3");
+var import_s3_request_presigner = require("@aws-sdk/s3-request-presigner");
+var import_functions = require("@vercel/functions");
+var getURLPrefix = (options) => `https://${options.bucket}.s3.${options.region}.amazonaws.com/`;
+function getHash(keys) {
+  return (0, import_node_crypto.createHash)("sha256").update(keys.join("/")).digest("hex");
+}
+var getFileURL = (options) => (keys) => {
+  if (typeof keys === "string") return `${getURLPrefix(options)}${keys}`;
+  return `${getURLPrefix(options)}${getHash(keys)}`;
+};
+var deleteImage = (client, options) => async (url) => {
+  const key = url.split(getURLPrefix(options))[1];
+  if (key) {
+    try {
+      await client.send(
+        new import_client_s3.DeleteObjectCommand({
+          Bucket: options.bucket,
+          Key: key
+        })
+      );
+      return true;
+    } catch (e) {
+      console.error("ERROR", url, e);
+    }
+  }
+  return false;
+};
+var uploadFile = (client, Bucket) => async (file, key) => {
+  const fileBuffer = await file.arrayBuffer();
+  return client.send(
+    new import_client_s3.PutObjectCommand({
+      Bucket,
+      Key: key,
+      ACL: "public-read",
+      Body: Buffer.from(fileBuffer),
+      ContentType: file.type,
+      ContentLength: file.size
+    })
+  );
+};
+
+// src/file/put.ts
+var getFileUploadPutRoute = (options, client) => async (req) => {
+  const ctx = getUserContext(options.refreshKey, options.signingKey, req);
+  if (!ctx?.accessUserId)
+    return import_server3.NextResponse.json({ error: "unauthorized" }, { status: 401 });
+  const formData = await req.formData();
+  const type = formData.get("type");
+  const sync = Boolean(formData.get("sync"));
+  const file = formData.get("file");
+  const data = formData.get("data");
+  const imageKey = (0, import_uuid.v4)();
+  const url = file ? getFileURL(options)(imageKey) : null;
+  const handleKeyProcessing = async () => {
+    if (file) await uploadFile(client, options.bucket)(file, imageKey);
+    if (!type || !ctx.accessUserId) return;
+    const { deleteURL, response } = await options.processFile({
+      url,
+      type,
+      userId: ctx.accessUserId,
+      data: typeof data === "string" ? JSON.parse(data) : void 0
+    });
+    if (deleteURL) await deleteImage(client, options)(deleteURL);
+    return response;
+  };
+  if (!sync) {
+    (0, import_functions2.waitUntil)(handleKeyProcessing());
+    return import_server3.NextResponse.json({ url });
+  } else {
+    return import_server3.NextResponse.json({
+      url,
+      response: await handleKeyProcessing()
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getFileUploadPutRoute
+});

package/dist/file/put.d.mts

@@ -0,0 +1,11 @@
+import { S3Client } from '@aws-sdk/client-s3';
+import { NextRequest, NextResponse } from 'next/server';
+import { SetupFileUploadOptions } from './setup.mjs';
+
+declare const getFileUploadPutRoute: (options: SetupFileUploadOptions, client: S3Client) => (req: NextRequest) => Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    url: string | null;
+}>>;
+
+export { getFileUploadPutRoute };

package/dist/file/put.d.ts

@@ -0,0 +1,11 @@
+import { S3Client } from '@aws-sdk/client-s3';
+import { NextRequest, NextResponse } from 'next/server';
+import { SetupFileUploadOptions } from './setup.js';
+
+declare const getFileUploadPutRoute: (options: SetupFileUploadOptions, client: S3Client) => (req: NextRequest) => Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    url: string | null;
+}>>;
+
+export { getFileUploadPutRoute };

package/dist/file/put.esm.js

@@ -0,0 +1,136 @@
+// src/file/put.ts
+import { waitUntil as waitUntil2 } from "@vercel/functions";
+import { NextResponse as NextResponse3 } from "next/server";
+import { v4 } from "uuid";
+
+// src/auth/email/utils.ts
+import { verify as verify2 } from "jsonwebtoken";
+
+// src/auth/email/token.ts
+import { compare } from "bcryptjs";
+import { JsonWebTokenError, sign, verify } from "jsonwebtoken";
+import { NextResponse } from "next/server";
+function getUserIdFromRefreshToken(refreshKey, refreshToken) {
+  if (refreshToken)
+    try {
+      const decoded = verify(refreshToken, refreshKey);
+      if (typeof decoded !== "string" && typeof decoded.id === "number")
+        return decoded.id;
+    } catch (e) {
+      if (!(e instanceof JsonWebTokenError)) console.error(e, "errors");
+      return null;
+    }
+  return null;
+}
+
+// src/auth/utils/errors.ts
+import { NextResponse as NextResponse2 } from "next/server";
+
+// src/auth/email/utils.ts
+var getUserContext = (refreshKey, signingKey, req) => {
+  const bearer = req.headers.get("authorization");
+  if (!bearer) {
+    const refresh = req.cookies.get("refresh")?.value;
+    const userId = getUserIdFromRefreshToken(refreshKey, refresh);
+    if (userId) return { refreshUserID: userId };
+    return null;
+  }
+  const token = bearer.slice(7);
+  try {
+    const res = verify2(token, signingKey);
+    if (typeof res === "string") {
+      return null;
+    }
+    return {
+      accessUserId: res.id
+    };
+  } catch {
+  }
+  return null;
+};
+
+// src/file/utils.ts
+import { createHash } from "crypto";
+import {
+  DeleteObjectCommand,
+  PutObjectCommand,
+  S3Client
+} from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+import { waitUntil } from "@vercel/functions";
+var getURLPrefix = (options) => `https://${options.bucket}.s3.${options.region}.amazonaws.com/`;
+function getHash(keys) {
+  return createHash("sha256").update(keys.join("/")).digest("hex");
+}
+var getFileURL = (options) => (keys) => {
+  if (typeof keys === "string") return `${getURLPrefix(options)}${keys}`;
+  return `${getURLPrefix(options)}${getHash(keys)}`;
+};
+var deleteImage = (client, options) => async (url) => {
+  const key = url.split(getURLPrefix(options))[1];
+  if (key) {
+    try {
+      await client.send(
+        new DeleteObjectCommand({
+          Bucket: options.bucket,
+          Key: key
+        })
+      );
+      return true;
+    } catch (e) {
+      console.error("ERROR", url, e);
+    }
+  }
+  return false;
+};
+var uploadFile = (client, Bucket) => async (file, key) => {
+  const fileBuffer = await file.arrayBuffer();
+  return client.send(
+    new PutObjectCommand({
+      Bucket,
+      Key: key,
+      ACL: "public-read",
+      Body: Buffer.from(fileBuffer),
+      ContentType: file.type,
+      ContentLength: file.size
+    })
+  );
+};
+
+// src/file/put.ts
+var getFileUploadPutRoute = (options, client) => async (req) => {
+  const ctx = getUserContext(options.refreshKey, options.signingKey, req);
+  if (!ctx?.accessUserId)
+    return NextResponse3.json({ error: "unauthorized" }, { status: 401 });
+  const formData = await req.formData();
+  const type = formData.get("type");
+  const sync = Boolean(formData.get("sync"));
+  const file = formData.get("file");
+  const data = formData.get("data");
+  const imageKey = v4();
+  const url = file ? getFileURL(options)(imageKey) : null;
+  const handleKeyProcessing = async () => {
+    if (file) await uploadFile(client, options.bucket)(file, imageKey);
+    if (!type || !ctx.accessUserId) return;
+    const { deleteURL, response } = await options.processFile({
+      url,
+      type,
+      userId: ctx.accessUserId,
+      data: typeof data === "string" ? JSON.parse(data) : void 0
+    });
+    if (deleteURL) await deleteImage(client, options)(deleteURL);
+    return response;
+  };
+  if (!sync) {
+    waitUntil2(handleKeyProcessing());
+    return NextResponse3.json({ url });
+  } else {
+    return NextResponse3.json({
+      url,
+      response: await handleKeyProcessing()
+    });
+  }
+};
+export {
+  getFileUploadPutRoute
+};

package/dist/file/setup.cjs.js

@@ -0,0 +1,195 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/file/setup.ts
+var setup_exports = {};
+__export(setup_exports, {
+  setupFileUpload: () => setupFileUpload
+});
+module.exports = __toCommonJS(setup_exports);
+
+// src/file/put.ts
+var import_functions2 = require("@vercel/functions");
+var import_server3 = require("next/server");
+var import_uuid = require("uuid");
+
+// src/auth/email/utils.ts
+var import_jsonwebtoken2 = require("jsonwebtoken");
+
+// src/auth/email/token.ts
+var import_bcryptjs = require("bcryptjs");
+var import_jsonwebtoken = require("jsonwebtoken");
+var import_server = require("next/server");
+function getUserIdFromRefreshToken(refreshKey, refreshToken) {
+  if (refreshToken)
+    try {
+      const decoded = (0, import_jsonwebtoken.verify)(refreshToken, refreshKey);
+      if (typeof decoded !== "string" && typeof decoded.id === "number")
+        return decoded.id;
+    } catch (e) {
+      if (!(e instanceof import_jsonwebtoken.JsonWebTokenError)) console.error(e, "errors");
+      return null;
+    }
+  return null;
+}
+
+// src/auth/utils/errors.ts
+var import_server2 = require("next/server");
+
+// src/auth/email/utils.ts
+var getUserContext = (refreshKey, signingKey, req) => {
+  const bearer = req.headers.get("authorization");
+  if (!bearer) {
+    const refresh = req.cookies.get("refresh")?.value;
+    const userId = getUserIdFromRefreshToken(refreshKey, refresh);
+    if (userId) return { refreshUserID: userId };
+    return null;
+  }
+  const token = bearer.slice(7);
+  try {
+    const res = (0, import_jsonwebtoken2.verify)(token, signingKey);
+    if (typeof res === "string") {
+      return null;
+    }
+    return {
+      accessUserId: res.id
+    };
+  } catch {
+  }
+  return null;
+};
+
+// src/file/utils.ts
+var import_node_crypto = require("crypto");
+var import_client_s3 = require("@aws-sdk/client-s3");
+var import_s3_request_presigner = require("@aws-sdk/s3-request-presigner");
+var import_functions = require("@vercel/functions");
+var getS3Client = (options) => new import_client_s3.S3Client({
+  region: options.region,
+  credentials: {
+    accessKeyId: options.awsKey,
+    secretAccessKey: options.awsSecret
+  }
+});
+var getURLPrefix = (options) => `https://${options.bucket}.s3.${options.region}.amazonaws.com/`;
+function getHash(keys) {
+  return (0, import_node_crypto.createHash)("sha256").update(keys.join("/")).digest("hex");
+}
+var getUploadFileURL = (client, Bucket) => (keys, isPublic) => {
+  const command = new import_client_s3.PutObjectCommand({
+    Bucket,
+    Key: getHash(keys),
+    ACL: isPublic ? "public-read" : void 0
+  });
+  return (0, import_s3_request_presigner.getSignedUrl)(client, command, { expiresIn: 300 });
+};
+var getFileURL = (options) => (keys) => {
+  if (typeof keys === "string") return `${getURLPrefix(options)}${keys}`;
+  return `${getURLPrefix(options)}${getHash(keys)}`;
+};
+var uploadImage = (client, options) => async (url, key, blob) => {
+  const photoBlob = blob || await fetch(url).then((file) => file.blob());
+  if (photoBlob) {
+    (0, import_functions.waitUntil)(uploadFile(client, options.bucket)(photoBlob, getHash(key)));
+    return getFileURL(options)(key);
+  }
+  return null;
+};
+var deleteImage = (client, options) => async (url) => {
+  const key = url.split(getURLPrefix(options))[1];
+  if (key) {
+    try {
+      await client.send(
+        new import_client_s3.DeleteObjectCommand({
+          Bucket: options.bucket,
+          Key: key
+        })
+      );
+      return true;
+    } catch (e) {
+      console.error("ERROR", url, e);
+    }
+  }
+  return false;
+};
+var uploadFile = (client, Bucket) => async (file, key) => {
+  const fileBuffer = await file.arrayBuffer();
+  return client.send(
+    new import_client_s3.PutObjectCommand({
+      Bucket,
+      Key: key,
+      ACL: "public-read",
+      Body: Buffer.from(fileBuffer),
+      ContentType: file.type,
+      ContentLength: file.size
+    })
+  );
+};
+
+// src/file/put.ts
+var getFileUploadPutRoute = (options, client) => async (req) => {
+  const ctx = getUserContext(options.refreshKey, options.signingKey, req);
+  if (!ctx?.accessUserId)
+    return import_server3.NextResponse.json({ error: "unauthorized" }, { status: 401 });
+  const formData = await req.formData();
+  const type = formData.get("type");
+  const sync = Boolean(formData.get("sync"));
+  const file = formData.get("file");
+  const data = formData.get("data");
+  const imageKey = (0, import_uuid.v4)();
+  const url = file ? getFileURL(options)(imageKey) : null;
+  const handleKeyProcessing = async () => {
+    if (file) await uploadFile(client, options.bucket)(file, imageKey);
+    if (!type || !ctx.accessUserId) return;
+    const { deleteURL, response } = await options.processFile({
+      url,
+      type,
+      userId: ctx.accessUserId,
+      data: typeof data === "string" ? JSON.parse(data) : void 0
+    });
+    if (deleteURL) await deleteImage(client, options)(deleteURL);
+    return response;
+  };
+  if (!sync) {
+    (0, import_functions2.waitUntil)(handleKeyProcessing());
+    return import_server3.NextResponse.json({ url });
+  } else {
+    return import_server3.NextResponse.json({
+      url,
+      response: await handleKeyProcessing()
+    });
+  }
+};
+
+// src/file/setup.ts
+function setupFileUpload(options) {
+  const client = getS3Client(options);
+  return {
+    PUT: getFileUploadPutRoute(options, client),
+    getUploadFileURL: getUploadFileURL(client, options.bucket),
+    uploadImage: uploadImage(client, options),
+    deleteImage: deleteImage(client, options),
+    getFileURL: getFileURL(options),
+    uploadFile: uploadFile(client, options.bucket)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setupFileUpload
+});

package/dist/file/setup.d.mts

@@ -0,0 +1,34 @@
+import * as _aws_sdk_client_s3 from '@aws-sdk/client-s3';
+import * as next_server from 'next/server';
+
+interface SetupFileUploadOptions {
+    refreshKey: string;
+    signingKey: string;
+    region: string;
+    bucket: string;
+    awsSecret: string;
+    awsKey: string;
+    processFile: (data: {
+        url: string | null;
+        type: string;
+        userId: number;
+        data: object;
+    }) => Promise<{
+        deleteURL?: string;
+        response?: object;
+    }>;
+}
+declare function setupFileUpload(options: SetupFileUploadOptions): {
+    PUT: (req: next_server.NextRequest) => Promise<next_server.NextResponse<{
+        error: string;
+    }> | next_server.NextResponse<{
+        url: string | null;
+    }>>;
+    getUploadFileURL: (keys: string[], isPublic?: boolean) => Promise<string>;
+    uploadImage: (url: string, key: string[], blob?: Blob) => Promise<string | null>;
+    deleteImage: (url: string) => Promise<boolean>;
+    getFileURL: (keys: string | string[]) => string;
+    uploadFile: (file: File | Blob, key: string) => Promise<_aws_sdk_client_s3.PutObjectCommandOutput>;
+};
+
+export { type SetupFileUploadOptions, setupFileUpload };

package/dist/file/setup.d.ts

@@ -0,0 +1,34 @@
+import * as _aws_sdk_client_s3 from '@aws-sdk/client-s3';
+import * as next_server from 'next/server';
+
+interface SetupFileUploadOptions {
+    refreshKey: string;
+    signingKey: string;
+    region: string;
+    bucket: string;
+    awsSecret: string;
+    awsKey: string;
+    processFile: (data: {
+        url: string | null;
+        type: string;
+        userId: number;
+        data: object;
+    }) => Promise<{
+        deleteURL?: string;
+        response?: object;
+    }>;
+}
+declare function setupFileUpload(options: SetupFileUploadOptions): {
+    PUT: (req: next_server.NextRequest) => Promise<next_server.NextResponse<{
+        error: string;
+    }> | next_server.NextResponse<{
+        url: string | null;
+    }>>;
+    getUploadFileURL: (keys: string[], isPublic?: boolean) => Promise<string>;
+    uploadImage: (url: string, key: string[], blob?: Blob) => Promise<string | null>;
+    deleteImage: (url: string) => Promise<boolean>;
+    getFileURL: (keys: string | string[]) => string;
+    uploadFile: (file: File | Blob, key: string) => Promise<_aws_sdk_client_s3.PutObjectCommandOutput>;
+};
+
+export { type SetupFileUploadOptions, setupFileUpload };