@conorroberts/utils 0.0.4

package/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

package/biome.json

@@ -0,0 +1,53 @@
+{
+	"$schema": "https://biomejs.dev/schemas/1.8.3/schema.json",
+	"organizeImports": {
+		"enabled": false
+	},
+	"linter": {
+		"enabled": true,
+		"rules": {
+			"recommended": true,
+			"correctness": {
+				"noUnusedImports": "error",
+				"noUnusedVariables": "error",
+				"noUnusedLabels": "error",
+				"useHookAtTopLevel": "error",
+				"noUndeclaredVariables": "error",
+				"useJsxKeyInIterable": "error"
+			},
+			"suspicious": {
+				"noExplicitAny": "off"
+			},
+			"a11y": {
+				"useMediaCaption": "off",
+				"useAltText": "off",
+				"useKeyWithClickEvents": "off",
+				"useKeyWithMouseEvents": "off",
+				"noSvgWithoutTitle": "off"
+			},
+			"style": {
+				"noParameterAssign": "off",
+				"noUselessElse": "off"
+			},
+			"complexity": {
+				"noForEach": "off"
+			}
+		},
+		"include": [
+			"**/*.ts",
+			"**/*.tsx",
+			"**/*.json"
+		]
+	},
+	"javascript": {
+		"formatter": {
+			"arrowParentheses": "always",
+			"lineWidth": 120,
+			"indentWidth": 2,
+			"quoteStyle": "double",
+			"trailingComma": "all",
+			"lineEnding": "crlf",
+			"indentStyle": "space"
+		}
+	}
+}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@conorroberts/utils",
+  "description": "",
+  "private": false,
+  "type": "module",
+  "exports": {
+    "./db": {
+      "types": "./dist/db.d.ts",
+      "default": "./dist/db.js"
+    },
+    "./schema": {
+      "types": "./dist/schema.d.ts",
+      "default": "./dist/schema.js"
+    },
+    "./logger": {
+      "types": "./dist/logger.d.ts",
+      "default": "./dist/logger.js"
+    },
+    "./cache": {
+      "types": "./dist/cache.d.ts",
+      "default": "./dist/cache.js"
+    },
+    "./env": {
+      "types": "./dist/env.d.ts",
+      "default": "./dist/env.js"
+    },
+    "./images": {
+      "types": "./dist/images.d.ts",
+      "default": "./dist/images.js"
+    }
+  },
+  "dependencies": {
+    "@libsql/client": "^0.6.0",
+    "@logtail/pino": "^0.4.17",
+    "@paralleldrive/cuid2": "^2.2.2",
+    "dayjs": "^1.11.11",
+    "drizzle-orm": "^0.31.0",
+    "ioredis": "^5.4.1",
+    "ofetch": "^1.3.4",
+    "pino": "^9.1.0",
+    "pino-pretty": "^10.3.1",
+    "remeda": "^2.0.10",
+    "unstorage": "^1.10.2",
+    "valibot": "0.30.0"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@biomejs/biome": "^1.8.3",
+    "tsup": "^8.0.1",
+    "typescript": "^5.4.5"
+  },
+  "version": "0.0.4",
+  "scripts": {
+    "dev": "tsup --watch",
+    "build": "tsc --noEmit && tsup",
+    "build:clean": "tsc --noEmit && tsup --clean"
+  }
+}

package/publish.sh

@@ -0,0 +1,2 @@
+pnpm version patch
+pnpm publish --access public

package/src/cache.ts

@@ -0,0 +1,24 @@
+import {
+  createStorage as createUnstorage,
+  type Storage,
+  type StorageValue,
+} from "unstorage";
+import redisDriver, { type RedisOptions } from "unstorage/drivers/redis";
+
+export class Cache {
+  private _cache: Storage<StorageValue>;
+
+  constructor(args: RedisOptions) {
+    this._cache = createUnstorage({
+      driver: redisDriver(args),
+    });
+  }
+
+  get cache() {
+    return this._cache;
+  }
+
+  public ttl(date: Date) {
+    return Math.floor((date.getTime() - Date.now()) / 1000);
+  }
+}

package/src/db.ts

@@ -0,0 +1,28 @@
+import { createClient } from "@libsql/client";
+import { LibSQLDatabase, drizzle } from "drizzle-orm/libsql";
+
+export const createLibsqlClient = (args: {
+  url: string;
+  authToken?: string;
+}) => {
+  return createClient(args);
+};
+
+export const createDbClient = <TSchema extends Record<string, unknown>>(
+  schema: TSchema,
+  args: { url: string; authToken?: string }
+) => {
+  const client = createLibsqlClient(args);
+  const db = drizzle(client, {
+    schema,
+    logger: false,
+  });
+
+  return db;
+};
+
+export type DatabaseClient<TSchema extends Record<string, unknown>> =
+  LibSQLDatabase<TSchema>;
+export type DatabaseClientTransactionContext<
+  TSchema extends Record<string, unknown>
+> = Parameters<Parameters<DatabaseClient<TSchema>["transaction"]>[0]>[0];

package/src/env.ts

@@ -0,0 +1,52 @@
+import { pipe } from "remeda";
+import type { BaseSchema, Output } from "valibot";
+import * as v from "valibot";
+
+const PUBLIC_ENV_PREFIX = "PUBLIC_" as const;
+
+/**
+ * Validates your environment variables against the given Valibot schema;
+ * @param args
+ * @returns An object containing client environment variables and another containing server environment variables
+ */
+export const createEnv = <
+  Schema extends Record<string, BaseSchema>,
+  Env = {
+    [K in keyof Schema]: Output<Schema[K]>;
+  },
+>(args: {
+  schema: Schema;
+  env: any;
+}) => {
+  const pairs = Object.entries(args.schema);
+  const serverEnv = new Map();
+
+  for (const [key, value] of pairs) {
+    const result = v.safeParse(value, args.env[key] ?? null);
+
+    if (!result.success) {
+      console.error(`Environment variable "${key}" is invalid`);
+      process.exit(1);
+    }
+
+    serverEnv.set(key, result.output);
+  }
+
+  type ClientEnvKeys = Exclude<
+    { [K in keyof Env]: K extends `${typeof PUBLIC_ENV_PREFIX}${string}` ? K : never }[keyof Env],
+    undefined
+  >;
+
+  type ClientEnv = {
+    [B in ClientEnvKeys]: Env[B];
+  };
+
+  const clientEnv = pipe(
+    serverEnv,
+    (obj) => Array.from(obj.entries()),
+    (pairs) => pairs.filter(([k]) => k.startsWith(PUBLIC_ENV_PREFIX)),
+    (pairs) => Object.fromEntries(pairs),
+  ) as ClientEnv;
+
+  return { client: clientEnv, server: Object.fromEntries(serverEnv.entries()) as Env };
+};

package/src/images.ts

@@ -0,0 +1,223 @@
+import { createId } from "@paralleldrive/cuid2";
+import dayjs from "dayjs";
+import { ofetch } from "ofetch";
+
+export interface OptimizedImageOptions {
+  anim?: boolean;
+  background?: string;
+  blur?: number;
+  brightness?: number;
+  compression?: "fast"; // faster compression = larger file size
+  contrast?: number;
+  dpr?: number;
+  fit?: "scale-down" | "contain" | "cover" | "crop" | "pad";
+  format?: "webp" | "avif" | "json";
+  gamma?: number;
+  width?: number;
+  height?: number;
+  metadata?: "keep" | "copyright" | "none";
+  quality?: number;
+  rotate?: number;
+  sharpen?: number;
+}
+
+export interface CreateImageUrlResponse {
+  result: {
+    id: string;
+    uploadURL: string;
+  };
+  success: boolean;
+  errors: unknown[];
+  messages: unknown[];
+}
+
+interface UploadImageResponse {
+  result: {
+    id: string;
+    filename: string;
+    uploaded: string;
+    requireSignedURLs: boolean;
+    variants: string[];
+  };
+  success: boolean;
+  errors: unknown[];
+  messages: unknown[];
+}
+
+export class ImageUtils<ImageIds extends Record<string, string>> {
+  private blacklist: string[] = ["img.clerk.com"];
+  private account: string;
+  private _imageIds: ImageIds | undefined;
+
+  constructor(args: {
+    accountId: string;
+    blacklist?: string[];
+    imageIds?: ImageIds;
+  }) {
+    this.account = args.accountId;
+
+    this._imageIds = args.imageIds;
+
+    if (args.blacklist) {
+      this.blacklist.push(...args.blacklist);
+    }
+  }
+
+  get imageIds() {
+    if (!this._imageIds) {
+      throw new Error(`imageIds was not supplied in constructor`);
+    }
+
+    return this._imageIds;
+  }
+
+  public url(id: string) {
+    return `https://imagedelivery.net/${this.account}/${id}/public`;
+  }
+
+  private isBlacklisted(url: string) {
+    return this.blacklist.some((u) => url.includes(u));
+  }
+
+  private isProtected(id: string) {
+    if (!this._imageIds) {
+      return false;
+    }
+
+    return Object.values(this._imageIds).some((e) => e === id);
+  }
+
+  /**
+   * Will only operate on images that have been uploaded via cloudflare images
+   */
+  public optimizeUrl(url: string, options: OptimizedImageOptions) {
+    if (this.isBlacklisted(url)) {
+      return url;
+    }
+
+    // Final format should look similar to: https://imagedelivery.net/<ACCOUNT_HASH>/<IMAGE_ID>/w=400,sharpen=3
+    return url.replace("public", this.createImageOptionsString(options));
+  }
+
+  public optimizeId(id: string, options: OptimizedImageOptions) {
+    return this.optimizeUrl(this.url(id), options);
+  }
+
+  public createOptionsSearchParams(options: OptimizedImageOptions) {
+    const params = new URLSearchParams();
+
+    const pairs = Object.entries(options);
+
+    for (const [key, val] of pairs) {
+      if (val === undefined) {
+        continue;
+      }
+
+      params.set(key, val.toString());
+    }
+
+    return params;
+  }
+
+  public createImageOptionsString(options: OptimizedImageOptions) {
+    const params = this.createOptionsSearchParams(options);
+
+    return Array.from(params.entries())
+      .map(([key, val]) => `${key}=${val}`)
+      .join(",");
+  }
+
+  public async createUploadUrls(count: number, args: { apiKey: string }) {
+    if (count === 0) {
+      return [];
+    }
+
+    const headers = new Headers();
+    headers.set("Authorization", `Bearer ${args.apiKey}`);
+
+    const urls = await Promise.all(
+      Array.from({ length: count }).map(async () => {
+        try {
+          const form = new FormData();
+          const id = createId();
+          form.append("id", id);
+          form.append("expiry", dayjs().add(5, "minute").toISOString());
+
+          const img = await ofetch<CreateImageUrlResponse>(
+            `https://api.cloudflare.com/client/v4/accounts/${this.account}/images/v2/direct_upload`,
+            { method: "POST", headers, body: form }
+          );
+
+          if (!img.success) {
+            throw new Error("Error uploading image");
+          }
+
+          return { url: img.result.uploadURL, id };
+        } catch (e) {
+          throw e;
+        }
+      })
+    );
+
+    return urls;
+  }
+
+  public async upload(url: string, body: FormData) {
+    const fetchResponse = await ofetch<UploadImageResponse>(url, {
+      method: "POST",
+      body,
+    });
+
+    if (!fetchResponse.success) {
+      throw new Error("Failed to upload image");
+    }
+
+    const downloadUrl = fetchResponse.result.variants[0];
+
+    if (!downloadUrl) {
+      throw new Error("Could not find download URL");
+    }
+
+    return downloadUrl;
+  }
+
+  public async delete(id: string, args: { apiKey: string }) {
+    if (this.isProtected(id)) {
+      return { success: true };
+    }
+
+    try {
+      const headers = new Headers();
+      headers.set("Authorization", `Bearer ${args.apiKey}`);
+
+      await ofetch(
+        `https://api.cloudflare.com/client/v4/accounts/${this.account}/images/v1/${id}`,
+        {
+          method: "POST",
+          headers,
+        }
+      );
+      return { success: true };
+    } catch (_e) {
+      return { success: false };
+    }
+  }
+
+  public async batchUpload(
+    files: { file: File; url: { id: string; value: string } }[]
+  ) {
+    return await Promise.all(
+      files.map(async (e) => {
+        const formData = new FormData();
+        formData.append("file", e.file);
+
+        const downloadUrl = await this.upload(e.url.value, formData);
+
+        return {
+          url: downloadUrl,
+          id: e.url.id,
+        };
+      })
+    );
+  }
+}

package/src/logger.ts

@@ -0,0 +1,30 @@
+import { pino } from "pino";
+
+export const createLogger = (args: {
+  token?: string | undefined | null;
+  pretty?: boolean;
+  service: string;
+}) => {
+  const l = pino(
+    {
+      level: "info",
+      redact: [],
+      transport: args.pretty
+        ? {
+            target: "pino-pretty",
+          }
+        : undefined,
+    },
+
+    args.token
+      ? pino.transport({
+          target: "@logtail/pino",
+          options: { sourceToken: args.token },
+        })
+      : undefined,
+  );
+
+  l.child({ service: args.service });
+
+  return l;
+};

package/src/migrate.ts

@@ -0,0 +1,41 @@
+import { createClient } from "@libsql/client";
+import { drizzle } from "drizzle-orm/libsql";
+import { migrate as runDrizzleMigrate } from "drizzle-orm/libsql/migrator";
+
+export const migrate = async <TSchema extends Record<string, any>>(
+  schema: TSchema,
+  args: {
+    url: string;
+    token?: string;
+    migrationsFolder: string;
+  }
+) => {
+  let url = args.url;
+
+  // Migrations are only supported via the libsql protocol
+  if (url.startsWith("http")) {
+    url = url.replace(/http(s)?/, "libsql");
+  }
+
+  const db = drizzle(
+    createClient(
+      // Auth token must be either 1) present and not undefined or 2) not present
+      args.token
+        ? {
+            url,
+            authToken: args.token,
+          }
+        : { url }
+    ),
+    { schema }
+  );
+
+  console.info("Running migrations");
+
+  await runDrizzleMigrate(db, {
+    migrationsFolder: args.migrationsFolder,
+  });
+
+  console.info("Migrations applied");
+  process.exit(0);
+};

package/src/schema.ts

@@ -0,0 +1,23 @@
+import { createId } from "@paralleldrive/cuid2";
+import { int, text } from "drizzle-orm/sqlite-core";
+
+const timeColumns = {
+  createdAt: int("created_at", { mode: "timestamp_ms" })
+    .notNull()
+    .$defaultFn(() => new Date()),
+  updatedAt: int("updated_at", { mode: "timestamp_ms" })
+    .notNull()
+    .$defaultFn(() => new Date()),
+};
+
+const commonColumns = {
+  id: text("id")
+    .primaryKey()
+    .$defaultFn(() => createId()),
+  ...timeColumns,
+};
+
+export const columns = {
+  time: timeColumns,
+  common: commonColumns,
+};

package/src/utils.ts

@@ -0,0 +1,3 @@
+import { init } from "@paralleldrive/cuid2";
+
+export const createRequestId = init({ length: 5 });

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "target": "es2022",
+    "verbatimModuleSyntax": true,
+    "allowJs": true,
+    "resolveJsonModule": true,
+    "moduleDetection": "force",
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "moduleResolution": "Bundler",
+    "module": "ESNext",
+    "noEmit": true,
+    "lib": ["DOM", "DOM.Iterable", "ES2022"],
+    "baseUrl": "."
+  },
+  "include": ["src/**/*", "package.json"]
+}

package/tsup.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  format: ["esm"],
+  sourcemap: true,
+  dts: true,
+  entry: {
+    schema: "src/schema.ts",
+    db: "src/db.ts",
+    cache: "src/cache.ts",
+    logger: "src/logger.ts",
+    env: "src/env.ts",
+    images: "src/images.ts",
+  },
+});