codeblog-app 0.1.0

package/src/storage/schema.sql.ts

@@ -0,0 +1,39 @@
+import { integer, text, sqliteTable } from "drizzle-orm/sqlite-core"
+
+export const Timestamps = {
+  time_created: integer()
+    .notNull()
+    .$default(() => Date.now()),
+  time_updated: integer()
+    .notNull()
+    .$onUpdate(() => Date.now()),
+}
+
+export const published_sessions = sqliteTable("published_sessions", {
+  id: text().primaryKey(),
+  session_id: text().notNull(),
+  source: text().notNull(),
+  post_id: text(),
+  file_path: text().notNull(),
+  ...Timestamps,
+})
+
+export const cached_posts = sqliteTable("cached_posts", {
+  id: text().primaryKey(),
+  title: text().notNull(),
+  content: text().notNull(),
+  author_name: text(),
+  votes: integer().default(0),
+  comments_count: integer().default(0),
+  tags: text(),
+  ...Timestamps,
+})
+
+export const notifications_cache = sqliteTable("notifications_cache", {
+  id: text().primaryKey(),
+  type: text().notNull(),
+  message: text().notNull(),
+  read: integer().default(0),
+  post_id: text(),
+  ...Timestamps,
+})

package/src/storage/schema.ts

@@ -0,0 +1 @@
+export { published_sessions, cached_posts, notifications_cache } from "./schema.sql"

package/src/util/__tests__/context.test.ts

@@ -0,0 +1,31 @@
+import { describe, test, expect } from "bun:test"
+import { Context } from "../context"
+
+describe("Context", () => {
+  test("create and provide context", () => {
+    const ctx = Context.create<string>("test")
+
+    Context.provide(ctx, "hello", () => {
+      expect(Context.use(ctx)).toBe("hello")
+    })
+  })
+
+  test("use returns undefined outside provider", () => {
+    const ctx = Context.create<number>("num")
+    expect(Context.use(ctx)).toBeUndefined()
+  })
+
+  test("nested contexts work correctly", () => {
+    const ctx = Context.create<string>("nested")
+
+    Context.provide(ctx, "outer", () => {
+      expect(Context.use(ctx)).toBe("outer")
+
+      Context.provide(ctx, "inner", () => {
+        expect(Context.use(ctx)).toBe("inner")
+      })
+
+      expect(Context.use(ctx)).toBe("outer")
+    })
+  })
+})

package/src/util/__tests__/lazy.test.ts

@@ -0,0 +1,37 @@
+import { describe, test, expect } from "bun:test"
+import { Lazy } from "../lazy"
+
+describe("Lazy", () => {
+  test("initializes value on first call", () => {
+    let count = 0
+    const lazy = Lazy.create(() => {
+      count++
+      return 42
+    })
+    expect(lazy()).toBe(42)
+    expect(count).toBe(1)
+  })
+
+  test("caches value on subsequent calls", () => {
+    let count = 0
+    const lazy = Lazy.create(() => {
+      count++
+      return "hello"
+    })
+    lazy()
+    lazy()
+    lazy()
+    expect(count).toBe(1)
+  })
+
+  test("reset clears cached value", () => {
+    let count = 0
+    const lazy = Lazy.create(() => {
+      count++
+      return count
+    })
+    expect(lazy()).toBe(1)
+    lazy.reset()
+    expect(lazy()).toBe(2)
+  })
+})

package/src/util/context.ts

@@ -0,0 +1,23 @@
+import { AsyncLocalStorage } from "async_hooks"
+
+export namespace Context {
+  export class NotFound extends Error {
+    constructor(public override readonly name: string) {
+      super(`No context found for ${name}`)
+    }
+  }
+
+  export function create<T>(name: string) {
+    const storage = new AsyncLocalStorage<T>()
+    return {
+      use() {
+        const result = storage.getStore()
+        if (!result) throw new NotFound(name)
+        return result
+      },
+      provide<R>(value: T, fn: () => R) {
+        return storage.run(value, fn)
+      },
+    }
+  }
+}

package/src/util/error.ts

@@ -0,0 +1,46 @@
+import z from "zod"
+
+export abstract class NamedError extends Error {
+  abstract schema(): z.core.$ZodType
+  abstract toObject(): { name: string; data: any }
+
+  static create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data) {
+    const schema = z
+      .object({
+        name: z.literal(name),
+        data,
+      })
+      .meta({ ref: name })
+    const result = class extends NamedError {
+      public static readonly Schema = schema
+      public override readonly name = name as Name
+
+      constructor(
+        public readonly data: z.input<Data>,
+        options?: ErrorOptions,
+      ) {
+        super(name, options)
+        this.name = name
+      }
+
+      static isInstance(input: any): input is InstanceType<typeof result> {
+        return typeof input === "object" && "name" in input && input.name === name
+      }
+
+      schema() {
+        return schema
+      }
+
+      toObject() {
+        return { name, data: this.data }
+      }
+    }
+    Object.defineProperty(result, "name", { value: name })
+    return result
+  }
+
+  public static readonly Unknown = NamedError.create(
+    "UnknownError",
+    z.object({ message: z.string() }),
+  )
+}

package/src/util/lazy.ts

@@ -0,0 +1,18 @@
+export function lazy<T>(fn: () => T) {
+  let value: T | undefined
+  let loaded = false
+
+  const result = (): T => {
+    if (loaded) return value as T
+    value = fn()
+    loaded = true
+    return value as T
+  }
+
+  result.reset = () => {
+    loaded = false
+    value = undefined
+  }
+
+  return result
+}

package/src/util/log.ts

@@ -0,0 +1,142 @@
+import path from "path"
+import fs from "fs/promises"
+import { Global } from "../global"
+import z from "zod"
+
+export namespace Log {
+  export const Level = z.enum(["DEBUG", "INFO", "WARN", "ERROR"]).meta({ ref: "LogLevel", description: "Log level" })
+  export type Level = z.infer<typeof Level>
+
+  const levelPriority: Record<Level, number> = {
+    DEBUG: 0,
+    INFO: 1,
+    WARN: 2,
+    ERROR: 3,
+  }
+
+  let level: Level = "INFO"
+
+  function shouldLog(input: Level): boolean {
+    return levelPriority[input] >= levelPriority[level]
+  }
+
+  export type Logger = {
+    debug(message?: any, extra?: Record<string, any>): void
+    info(message?: any, extra?: Record<string, any>): void
+    error(message?: any, extra?: Record<string, any>): void
+    warn(message?: any, extra?: Record<string, any>): void
+    tag(key: string, value: string): Logger
+    clone(): Logger
+  }
+
+  const loggers = new Map<string, Logger>()
+
+  export const Default = create({ service: "default" })
+
+  export interface Options {
+    print: boolean
+    dev?: boolean
+    level?: Level
+  }
+
+  let logpath = ""
+  export function file() {
+    return logpath
+  }
+  let write = (msg: any) => {
+    process.stderr.write(msg)
+    return msg.length
+  }
+
+  export async function init(options: Options) {
+    if (options.level) level = options.level
+    cleanup(Global.Path.log)
+    if (options.print) return
+    logpath = path.join(
+      Global.Path.log,
+      options.dev ? "dev.log" : new Date().toISOString().split(".")[0].replace(/:/g, "") + ".log",
+    )
+    const logfile = Bun.file(logpath)
+    await fs.truncate(logpath).catch(() => {})
+    const writer = logfile.writer()
+    write = async (msg: any) => {
+      const num = writer.write(msg)
+      writer.flush()
+      return num
+    }
+  }
+
+  async function cleanup(dir: string) {
+    const glob = new Bun.Glob("????-??-??T??????.log")
+    const files = await Array.fromAsync(
+      glob.scan({
+        cwd: dir,
+        absolute: true,
+      }),
+    )
+    if (files.length <= 5) return
+    const filesToDelete = files.slice(0, -10)
+    await Promise.all(filesToDelete.map((file) => fs.unlink(file).catch(() => {})))
+  }
+
+  function formatError(error: Error, depth = 0): string {
+    const result = error.message
+    return error.cause instanceof Error && depth < 10
+      ? result + " Caused by: " + formatError(error.cause, depth + 1)
+      : result
+  }
+
+  let last = Date.now()
+  export function create(tags?: Record<string, any>) {
+    tags = tags || {}
+
+    const service = tags["service"]
+    if (service && typeof service === "string") {
+      const cached = loggers.get(service)
+      if (cached) return cached
+    }
+
+    function build(message: any, extra?: Record<string, any>) {
+      const prefix = Object.entries({
+        ...tags,
+        ...extra,
+      })
+        .filter(([_, value]) => value !== undefined && value !== null)
+        .map(([key, value]) => {
+          const prefix = `${key}=`
+          if (value instanceof Error) return prefix + formatError(value)
+          if (typeof value === "object") return prefix + JSON.stringify(value)
+          return prefix + value
+        })
+        .join(" ")
+      const next = new Date()
+      const diff = next.getTime() - last
+      last = next.getTime()
+      return [next.toISOString().split(".")[0], "+" + diff + "ms", prefix, message].filter(Boolean).join(" ") + "\n"
+    }
+    const result: Logger = {
+      debug(message?: any, extra?: Record<string, any>) {
+        if (shouldLog("DEBUG")) write("DEBUG " + build(message, extra))
+      },
+      info(message?: any, extra?: Record<string, any>) {
+        if (shouldLog("INFO")) write("INFO  " + build(message, extra))
+      },
+      error(message?: any, extra?: Record<string, any>) {
+        if (shouldLog("ERROR")) write("ERROR " + build(message, extra))
+      },
+      warn(message?: any, extra?: Record<string, any>) {
+        if (shouldLog("WARN")) write("WARN  " + build(message, extra))
+      },
+      tag(key: string, value: string) {
+        if (tags) tags[key] = value
+        return result
+      },
+      clone() {
+        return Log.create({ ...tags })
+      },
+    }
+
+    if (service && typeof service === "string") loggers.set(service, result)
+    return result
+  }
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "@tsconfig/bun/tsconfig.json",
+  "compilerOptions": {
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  }
+}