holy fk docker works finally

.dockerignore

···
+node_modules
 **/node_modules
 **/*.md
+.git
+.gitignore
+**/dist
+.pnpm-store
+.DS_Store

.env.example

···
 # oauth
 PUBLIC_URL=
 PRIVATE_KEYS=
+COOKIE_SECRET=

Dockerfile

···
+FROM node:24-alpine AS base
+ENV PNPM_HOME="/pnpm"
+ENV PATH="$PNPM_HOME:$PATH"
+ENV NODE_ENV=production
+RUN corepack enable
+
+FROM base AS build
+COPY . /app
+WORKDIR /app
+
+RUN --mount=type=cache,id=pnpm,target=/pnpm/store pnpm install --frozen-lockfile
+RUN pnpm run -r build
+RUN pnpm deploy --filter=./apps/web --prod /prod/web
+
+FROM base AS web
+COPY --from=build /prod/web /prod/web
+WORKDIR /prod/web
+EXPOSE 8002
+CMD ["pnpm", "start"]

apps/bot/commands/auth.ts

···
-import { logger } from "@tealfmbot/common/logger.js";
+import { logger } from "@tealfmbot/common/logger";
 import {
   ChatInputCommandInteraction,
   InteractionContextType,

apps/bot/commands/ping.ts

···
-import { logger } from "@tealfmbot/common/logger.js";
+import { logger } from "@tealfmbot/common/logger";
 import { CommandInteraction, SlashCommandBuilder } from "discord.js";
 
 export default {

apps/bot/commands/top.ts

···
-import { logger } from "@tealfmbot/common/logger.js";
+import { logger } from "@tealfmbot/common/logger";
 import { CommandInteraction, SlashCommandBuilder } from "discord.js";
 
 export default {

apps/bot/deploy-commands.ts

···
   DISCORD_APPLICATION_ID,
   DISCORD_BOT_TOKEN,
   DISCORD_GUILD_ID,
-} from "@tealfmbot/common/constants.js";
+} from "@tealfmbot/common/constants";
 import { REST, Routes } from "discord.js";
 import fs from "node:fs";
 import path from "node:path";

apps/bot/main.ts

···
-import { DISCORD_BOT_TOKEN } from "@tealfmbot/common/constants.js";
-import { logger } from "@tealfmbot/common/logger.js";
+import { DISCORD_BOT_TOKEN } from "@tealfmbot/common/constants";
+import { logger } from "@tealfmbot/common/logger";
 import { Client, Collection, Events, GatewayIntentBits, MessageFlags } from "discord.js";
 import fs from "node:fs";
 import path from "node:path";

apps/tapper/index.ts

···
 import { SimpleIndexer, Tap } from "@atproto/tap";
-import { TAP_ADMIN_PASSWORD } from "@tealfmbot/common/constants.js";
+import { TAP_ADMIN_PASSWORD } from "@tealfmbot/common/constants";
 // import { db } from "./kysely/db.ts"
 
 const tap = new Tap("https://tap.xero.systems", {

apps/web/client.ts

···
   NodeOAuthClient,
   type OAuthClientMetadataInput,
 } from "@atproto/oauth-client-node";
-import { PUBLIC_URL, PRIVATE_KEYS } from "@tealfmbot/common/constants.js";
-import { db } from "@tealfmbot/database/db.ts";
+import { PUBLIC_URL, PRIVATE_KEYS } from "@tealfmbot/common/constants";
+import { db } from "@tealfmbot/database/db";
 import assert from "node:assert";
 
-import { SessionStore, StateStore } from "./storage";
+import { SessionStore, StateStore } from "./storage.js";
 
 const keyset =
   PUBLIC_URL && PRIVATE_KEYS

apps/web/index.ts

···
 import { serve, type HttpBindings } from "@hono/node-server";
-import { COOKIE_SECRET } from "@tealfmbot/common/constants.js";
-import { logger } from "@tealfmbot/common/logger.js";
+import { COOKIE_SECRET } from "@tealfmbot/common/constants";
+import { logger } from "@tealfmbot/common/logger";
 import { Hono } from "hono";
 import { deleteCookie, getSignedCookie } from "hono/cookie";
 import { html } from "hono/html";
 import { validator } from "hono/validator";
 import pinoHttpLogger from "pino-http";
 
-import { client } from "./client";
-import { createSession, getSessionAgent, MAX_AGE, validateIdentifier } from "./utils";
+import { client } from "./client.js";
+import { createSession, getSessionAgent, MAX_AGE, validateIdentifier } from "./utils.js";
 
 type Variables = {
   logger: typeof logger;

apps/web/package.json

···
   "scripts": {
     "dev": "tsx --watch index.ts",
     "build": "tsc",
-    "start": "tsx index.ts",
+    "start": "node dist/index.js",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {

apps/web/storage.ts

···
   NodeSavedState,
   NodeSavedStateStore,
 } from "@atproto/oauth-client-node";
-import type { Database } from "@tealfmbot/database/types.ts";
+import type { Database } from "@tealfmbot/database/types";
 
 export class StateStore implements NodeSavedStateStore {
   constructor(private db: Database) {}

apps/web/tsconfig.json

···
   "compilerOptions": {
     "outDir": "./dist",
     "target": "ESNext",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "lib": ["ESNext"],
   },
   "exclude": ["node_modules"]
 }

apps/web/utils.ts

···
 import { Agent } from "@atproto/api";
 import { isAtprotoDid, isAtprotoDidWeb } from "@atproto/did";
 import { isValidHandle } from "@atproto/syntax";
-import { COOKIE_SECRET } from "@tealfmbot/common/constants.js";
-import { logger } from "@tealfmbot/common/logger.js";
+import { COOKIE_SECRET } from "@tealfmbot/common/constants";
+import { logger } from "@tealfmbot/common/logger";
 import { deleteCookie, generateSignedCookie, getSignedCookie } from "hono/cookie";
 
-import { client } from "./client";
+import { client } from "./client.js";
 
 export const MAX_AGE = process.env.NODE_ENV === "production" ? 60 : 0;
 

package.json

···
     "bot": "pnpm --filter bot dev",
     "tap": "pnpm --filter tapper dev",
     "web": "pnpm --filter web dev",
+    "docker:web": "docker build . --target web --tag web:latest",
     "dev:all": "pnpm --filter './apps/**' dev",
     "typecheck": "pnpm --filter './apps/**' typecheck",
     "lint": "oxlint",

packages/common/constants.ts

···
 import path from "node:path";
 import { loadEnvFile } from "node:process";
 
-loadEnvFile(path.join(import.meta.dirname, "../../.env"));
+if (process.env.NODE_ENV !== "production") {
+  loadEnvFile(path.join(import.meta.dirname, "../../.env"));
+}
 
 export const DISCORD_BOT_TOKEN = process.env.DISCORD_BOT_TOKEN as string;
 export const DISCORD_APPLICATION_ID = process.env.DISCORD_APPLICATION_ID as string;

packages/common/index.ts

···
+export * from "./constants.js";
+export * from "./logger.js";

packages/common/logger.ts

···
 import pino from "pino";
 
-export const logger = pino({
-  transport: {
-    target: "pino-pretty",
-    options: {
-      colorize: true,
-    },
-  },
-});
+export const logger =
+  process.env.NODE_ENV === "production"
+    ? pino()
+    : pino({
+        transport: {
+          target: "pino-pretty",
+          options: {
+            colorize: true,
+          },
+        },
+      });

packages/common/package.json

···
   "private": true,
   "type": "module",
   "exports": {
-    "./*": "./*"
-  },
+    "./constants": {
+         "types": "./dist/constants.d.ts",
+         "import": "./dist/constants.js"
+       },
+       "./logger": {
+         "types": "./dist/logger.d.ts",
+         "import": "./dist/logger.js"
+       }
+    },
   "scripts": {
+    "build": "tsc",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {

packages/common/tsconfig.json

···
 {
-  "extends": "@tealfmbot/tsconfig/tsconfig.node.json"
+  "extends": "@tealfmbot/tsconfig/tsconfig.node.json",
+  "compilerOptions": {
+    "rootDir": ".",
+    "declaration": true,
+    "declarationMap": false,
+    "emitDeclarationOnly": false,
+    "outDir": "./dist"
+  }
 }

packages/database/database.d.ts

···
+/**
+ * This file was generated by kysely-codegen.
+ * Please do not edit it manually.
+ */
+
+import type { ColumnType } from "kysely";
+
+export type Generated<T> =
+  T extends ColumnType<infer S, infer I, infer U>
+    ? ColumnType<S, I | undefined, U>
+    : ColumnType<T, T | undefined, T>;
+
+export type Timestamp = ColumnType<Date, Date | string, Date | string>;
+
+export interface Artists {
+  artist_name: string;
+  play_id: number;
+}
+
+export interface AuthSession {
+  key: string;
+  session: string;
+}
+
+export interface AuthState {
+  key: string;
+  state: string;
+}
+
+export interface Plays {
+  id: Generated<number>;
+  indexed_at: Generated<Timestamp>;
+  played_time: Timestamp;
+  release_name: string;
+  track_name: string;
+  user_id: number;
+}
+
+export interface Users {
+  created_at: Generated<Timestamp>;
+  did: string;
+  id: Generated<number>;
+}
+
+export interface DB {
+  artists: Artists;
+  auth_session: AuthSession;
+  auth_state: AuthState;
+  plays: Plays;
+  users: Users;
+}

packages/database/db.ts

···
-import type { DB } from "kysely-codegen";
-
-import { DATABASE_URL } from "@tealfmbot/common/constants.js";
+import { DATABASE_URL } from "@tealfmbot/common/constants";
 import { Kysely, PostgresDialect } from "kysely";
 import { Pool } from "pg";
+
+import type { DB } from "./database.js";
 
 const dialect = new PostgresDialect({
   pool: new Pool({

packages/database/migrate.ts

···
-import type { DB } from "kysely-codegen";
-
-import { DATABASE_URL } from "@tealfmbot/common/constants.ts";
+import { DATABASE_URL } from "@tealfmbot/common/constants.js";
 import { Kysely, Migrator, PostgresDialect, FileMigrationProvider } from "kysely";
 import { run } from "kysely-migration-cli";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { Pool } from "pg";
+
+import type { DB } from "./database.js";
 
 async function migrateToLatest() {
   const migrationFolder = new URL("../migrations", import.meta.url).pathname;

packages/database/package.json

···
   "private": true,
   "type": "module",
   "exports": {
-    "./db.ts": "./db.ts",
-    "./types.ts": "./types.ts"
-  },
+    "./db": {
+      "types": "./dist/db.d.ts",
+      "import": "./dist/db.js"
+      },
+      "./types": {
+        "types": "./dist/types.d.ts",
+        "import": "./dist/types.js"
+        }
+    },
+  "types": "./database.d.ts",
   "scripts": {
+    "build": "tsc",
     "migrate": "kysely migrate latest",
-    "codegen": "kysely-codegen --dialect postgres --env-file='../../.env'",
+    "codegen": "kysely-codegen --dialect postgres --env-file='../../.env' --out-file ./database.d.ts",
     "seed": "tsx seed.ts",
     "typecheck": "tsc --noEmit"
   },

packages/database/tsconfig.json

···
 {
   "extends": "@tealfmbot/tsconfig/tsconfig.node.json",
-  "exclude": ["node_modules"]
+  "exclude": ["node_modules"],
+  "compilerOptions": {
+    "rootDir": ".",
+    "declaration": true,
+    "declarationMap": false,
+    "emitDeclarationOnly": false,
+    "outDir": "./dist"
+  },
+  "include": ["db.ts", "database.d.ts", "types.ts"]
 }

packages/database/types.ts

···
-// @ts-nocheck
-import type { Artists, Plays } from "kysely-codegen";
+import type { Kysely } from "kysely";
 
-import { db } from "./db.ts";
+import type { DB } from "./database.js";
 
-export type Database = typeof db;
-export interface TealFMPlay extends Plays {
-  artists: Artists;
-}
+export type Database = Kysely<DB>;

packages/tsconfig/tsconfig.node.json

···
 {
   "extends": "./tsconfig.base.json",
   "compilerOptions": {
+    "module": "ESNext",
+    "moduleResolution": "bundler",
     "lib": ["esnext"],
     "types": ["node"]
   }

pnpm-lock.yaml

···
 settings:
   autoInstallPeers: true
   excludeLinksFromLockfile: false
+  injectWorkspacePackages: true
 
 importers:
 

pnpm-workspace.yaml

···
 packages:
   - "apps/*"
   - "packages/*"
+
+blockExoticSubdeps: true
+minimumReleaseAge: 10080
+trustPolicy: no-downgrade
+syncInjectedDepsAfterScripts:
+  - build
+injectWorkspacePackages: true