@webtwizz/cloud 0.0.0-stage → 0.2.0

package/dist/db.d.ts

@@ -0,0 +1,9 @@
+import postgres from 'postgres';
+
+type DbOptions = postgres.Options<Record<string, postgres.PostgresType>> & {
+    url?: string;
+};
+type Db = postgres.Sql<Record<string, never>>;
+declare function createDb({ url, ...options }?: DbOptions): Db;
+
+export { type Db, type DbOptions, createDb };

package/dist/db.js

@@ -0,0 +1,13 @@
+import {
+  env
+} from "./chunk-ESAV545E.js";
+
+// src/db.ts
+import "server-only";
+import postgres from "postgres";
+function createDb({ url, ...options } = {}) {
+  return postgres(url ?? env("DATABASE_URL"), { ...options, prepare: false });
+}
+export {
+  createDb
+};

package/dist/files.d.ts

@@ -0,0 +1,35 @@
+type Bucket = 'public' | 'private';
+type UploadRequest = {
+    bucket: Bucket;
+    name: string;
+    type: string;
+    size: number;
+    folder?: string;
+    accept?: string[];
+};
+type Upload = {
+    url: string;
+    key: string;
+    headers: Record<string, string>;
+};
+declare class FileError extends Error {
+    code: 'too_large' | 'type';
+    constructor(code: 'too_large' | 'type', message: string);
+}
+declare function safeName(name: string): string;
+declare function accepts(type: string, accept: string[]): boolean;
+declare function createFiles(): {
+    maxFileMb: number;
+    /** A 5-minute link on the files address the browser PUTs the file to, with the exact headers it must send. */
+    uploadUrl({ bucket, name, type, size, folder, accept }: UploadRequest): Promise<Upload>;
+    publicUrl(key: string): string;
+    /** A short-lived link to a private file; check the visitor may see it first. */
+    privateUrl(key: string, { expiresIn, download }?: {
+        expiresIn?: number;
+        download?: string;
+    }): Promise<string>;
+    remove(bucket: Bucket, key: string): Promise<void>;
+};
+type Files = ReturnType<typeof createFiles>;
+
+export { type Bucket, FileError, type Files, type Upload, type UploadRequest, accepts, createFiles, safeName };

package/dist/files.js

@@ -0,0 +1,92 @@
+import {
+  MESSAGES
+} from "./chunk-G54JBUO3.js";
+import {
+  env
+} from "./chunk-ESAV545E.js";
+
+// src/files.ts
+import "server-only";
+import { DeleteObjectCommand, GetObjectCommand, PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+var FileError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "FileError";
+  }
+  code;
+};
+var IMMUTABLE = "public, max-age=31536000, immutable";
+function safeName(name) {
+  const cleaned = name.normalize("NFKD").replace(/[^\w.-]+/g, "-").replace(/-+/g, "-").replace(/^[-.]+|-+$/g, "");
+  return cleaned.slice(-80) || "file";
+}
+function accepts(type, accept) {
+  return accept.some((rule) => rule.endsWith("/*") ? type.startsWith(rule.slice(0, -1)) : type === rule);
+}
+function encodeKey(key) {
+  return key.split("/").map(encodeURIComponent).join("/");
+}
+function createFiles() {
+  const endpoint = env("WEBTWIZZ_STORAGE_ENDPOINT").replace(/\/+$/, "");
+  const filesUrl = (process.env.WEBTWIZZ_FILES_URL || endpoint).replace(/\/+$/, "");
+  const region = env("WEBTWIZZ_STORAGE_REGION");
+  const client = (key, secret) => new S3Client({
+    region,
+    endpoint,
+    forcePathStyle: true,
+    requestChecksumCalculation: "WHEN_REQUIRED",
+    credentials: { accessKeyId: env(key), secretAccessKey: env(secret) }
+  });
+  const writer = client("WEBTWIZZ_STORAGE_KEY", "WEBTWIZZ_STORAGE_SECRET");
+  let reader;
+  const maxFileMb = Number(process.env.WEBTWIZZ_STORAGE_MAX_FILE_MB) || 0;
+  const onFilesAddress = (url) => url.startsWith(`${endpoint}/`) ? filesUrl + url.slice(endpoint.length) : url;
+  return {
+    maxFileMb,
+    /** A 5-minute link on the files address the browser PUTs the file to, with the exact headers it must send. */
+    async uploadUrl({ bucket, name, type, size, folder, accept }) {
+      if (maxFileMb && size > maxFileMb * 1024 * 1024) throw new FileError("too_large", MESSAGES.fileTooLarge(maxFileMb));
+      if (accept && !accepts(type, accept)) throw new FileError("type", MESSAGES.fileType);
+      const prefix = folder ? `${folder.split("/").map(safeName).join("/")}/` : "";
+      const key = `${prefix}${crypto.randomUUID()}-${safeName(name)}`;
+      const headers = { "Content-Type": type };
+      if (bucket === "public") headers["Cache-Control"] = IMMUTABLE;
+      const command = new PutObjectCommand({
+        Bucket: bucket,
+        Key: key,
+        ContentType: type,
+        ContentLength: size,
+        CacheControl: headers["Cache-Control"]
+      });
+      const signed = await getSignedUrl(writer, command, {
+        expiresIn: 300,
+        signableHeaders: /* @__PURE__ */ new Set(["content-type", "content-length"])
+      });
+      return { url: onFilesAddress(signed), key, headers };
+    },
+    publicUrl(key) {
+      return `${filesUrl}/public/${encodeKey(key)}`;
+    },
+    /** A short-lived link to a private file; check the visitor may see it first. */
+    async privateUrl(key, { expiresIn = 300, download } = {}) {
+      reader ??= client("WEBTWIZZ_STORAGE_READ_KEY", "WEBTWIZZ_STORAGE_READ_SECRET");
+      const command = new GetObjectCommand({
+        Bucket: "private",
+        Key: key,
+        ResponseContentDisposition: download ? `attachment; filename="${safeName(download)}"` : void 0
+      });
+      return onFilesAddress(await getSignedUrl(reader, command, { expiresIn }));
+    },
+    async remove(bucket, key) {
+      await writer.send(new DeleteObjectCommand({ Bucket: bucket, Key: key }));
+    }
+  };
+}
+export {
+  FileError,
+  accepts,
+  createFiles,
+  safeName
+};

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+type CloudError = {
+    code?: string;
+    status?: number;
+} | null | undefined;
+declare const AUTH_MESSAGES: Record<string, string>;
+/** Plain words for a sign-in error, never the library's own text. */
+declare function authMessage(error: CloudError, overrides?: Record<string, string>): string;
+declare const MESSAGES: {
+    readonly unavailable: "This isn't available right now. Please try again later.";
+    readonly saveFailed: "Couldn't save right now. Please try again later.";
+    readonly uploadsPaused: "Uploads are paused right now. Please try again later.";
+    readonly fileType: "That type of file can't be uploaded here.";
+    readonly fileTooLarge: (mb: number) => string;
+};
+
+export { AUTH_MESSAGES, type CloudError, MESSAGES, authMessage };

package/dist/index.js

@@ -0,0 +1,10 @@
+import {
+  AUTH_MESSAGES,
+  MESSAGES,
+  authMessage
+} from "./chunk-G54JBUO3.js";
+export {
+  AUTH_MESSAGES,
+  MESSAGES,
+  authMessage
+};

package/dist/server.d.ts

@@ -0,0 +1,13 @@
+import { createNeonAuth } from '@neondatabase/auth/next/server';
+
+type AuthOptions = {
+    url?: string;
+    secret?: string;
+    sessionDataTtl?: number;
+};
+type Auth = ReturnType<typeof createNeonAuth>;
+/** What visitors get back: WebTwizz cookie names and none of the sign-in service's own headers. */
+declare function forBrowser<T extends Response>(response: T): T;
+declare function createAuth(options?: AuthOptions): Auth;
+
+export { type Auth, type AuthOptions, createAuth, forBrowser };