Fix type export & lint

Author: max-lt

.github/workflows/docker.yml

@@ -5,7 +5,7 @@ on:
     branches:
       - main
     tags:
-      - "v*"
+      - 'v*'
   pull_request:
     branches:
       - main

.github/workflows/npm-publish.yml

@@ -3,7 +3,7 @@ name: Publish to npm
 on:
   push:
     tags:
-      - "v*"
+      - 'v*'
 
 permissions:
   id-token: write # Required for OIDC
@@ -31,8 +31,8 @@ jobs:
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
-          node-version: "20"
-          registry-url: "https://registry.npmjs.org/"
+          node-version: '20'
+          registry-url: 'https://registry.npmjs.org/'
 
       # Ensure npm 11.5.1 or later for trusted publishing
       # https://github.com/orgs/community/discussions/173102#discussioncomment-14367428

.prettierrc

@@ -0,0 +1,9 @@
+{
+  "tabWidth": 2,
+  "useTabs": false,
+  "singleQuote": true,
+  "trailingComma": "none",
+  "endOfLine": "lf",
+  "arrowParens": "always",
+  "printWidth": 120
+}

CLAUDE.md

@@ -1,4 +1,3 @@
-
 Default to using Bun instead of Node.js.
 
 - Use `bun <file>` instead of `node <file>` or `ts-node <file>`

README.md

@@ -136,7 +136,7 @@ The `db.ts` service can be swapped between implementations:
 **Current**: Bun native Postgres
 
 ```typescript
-import { sql } from "bun";
+import { sql } from 'bun';
 ```
 
 **Future**: Postgres Gateway (HTTP-based)

package.json

@@ -10,6 +10,7 @@
     "start": "bun src/index.ts",
     "compile": "bun build --compile --minify --sourcemap server.ts --outfile dist/openworkers-api",
     "test": "bun test",
+    "lint": "prettier --write .",
     "generate-types": "bun scripts/generate-types.ts"
   },
   "dependencies": {

scripts/generate-types.ts

@@ -1,105 +1,86 @@
-import { version } from "../package.json";
-import { zodToTs } from "zod-to-ts";
-import ts from "typescript";
-import prettier from "prettier";
+import { version } from '../package.json';
+import { zodToTs } from 'zod-to-ts';
+import ts from 'typescript';
+import prettier from 'prettier';
 
 // Helper to print TypeScript node as string
 function printNode(node: ts.Node): string {
   const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
-  const sourceFile = ts.createSourceFile(
-    "temp.ts",
-    "",
-    ts.ScriptTarget.Latest,
-    false,
-    ts.ScriptKind.TS
-  );
+  const sourceFile = ts.createSourceFile('temp.ts', '', ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
   return printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);
 }
 
 // Import all schemas
-import {
-  ResourceSchema,
-  TimestampsSchema,
-} from "../src/types/schemas/base.schema";
+import { ResourceSchema, TimestampsSchema } from '../src/types/schemas/base.schema';
 
-import { LoginResponseSchema } from "../src/types/schemas/auth.schema";
+import { LoginResponseSchema } from '../src/types/schemas/auth.schema';
 
-import {
-  SelfSchema,
-  ResourceLimitsSchema,
-} from "../src/types/schemas/user.schema";
+import { SelfSchema, ResourceLimitsSchema } from '../src/types/schemas/user.schema';
 
 import {
   EnvironmentSchema,
   EnvironmentCreateInputSchema,
   EnvironmentUpdateInputSchema,
   EnvironmentValueSchema,
-  EnvironmentValueUpdateInputSchema,
-} from "../src/types/schemas/environment.schema";
+  EnvironmentValueUpdateInputSchema
+} from '../src/types/schemas/environment.schema';
 
-import {
-  CronSchema,
-  CronCreateInputSchema,
-  CronUpdateInputSchema,
-} from "../src/types/schemas/cron.schema";
+import { CronSchema, CronCreateInputSchema, CronUpdateInputSchema } from '../src/types/schemas/cron.schema';
 
-import {
-  DomainSchema,
-  DomainCreateInputSchema,
-} from "../src/types/schemas/domain.schema";
+import { DomainSchema, DomainCreateInputSchema } from '../src/types/schemas/domain.schema';
 
 import {
   WorkerSchema,
   WorkerCreateInputSchema,
   WorkerUpdateInputSchema,
-  WorkerLanguageSchema,
-} from "../src/types/schemas/worker.schema";
+  WorkerLanguageSchema
+} from '../src/types/schemas/worker.schema';
 
 // Schema definitions to generate
 const schemas = [
   // Base schemas
-  { schema: ResourceSchema, name: "Resource" },
-  { schema: TimestampsSchema, name: "Timestamps" },
+  { schema: ResourceSchema, name: 'Resource' },
+  { schema: TimestampsSchema, name: 'Timestamps' },
 
   // Auth
-  { schema: LoginResponseSchema, name: "LoginResponse" },
+  { schema: LoginResponseSchema, name: 'LoginResponse' },
 
   // User
-  { schema: SelfSchema, name: "Self" },
-  { schema: ResourceLimitsSchema, name: "ResourceLimits" },
+  { schema: SelfSchema, name: 'Self' },
+  { schema: ResourceLimitsSchema, name: 'ResourceLimits' },
 
   // Environment
-  { schema: EnvironmentSchema, name: "Environment" },
-  { schema: EnvironmentCreateInputSchema, name: "EnvironmentCreateInput" },
-  { schema: EnvironmentUpdateInputSchema, name: "EnvironmentUpdateInput" },
-  { schema: EnvironmentValueSchema, name: "EnvironmentValue" },
+  { schema: EnvironmentSchema, name: 'Environment' },
+  { schema: EnvironmentCreateInputSchema, name: 'EnvironmentCreateInput' },
+  { schema: EnvironmentUpdateInputSchema, name: 'EnvironmentUpdateInput' },
+  { schema: EnvironmentValueSchema, name: 'EnvironmentValue' },
   {
     schema: EnvironmentValueUpdateInputSchema,
-    name: "EnvironmentValueUpdateInput",
+    name: 'EnvironmentValueUpdateInput'
   },
 
   // Cron
-  { schema: CronSchema, name: "Cron" },
-  { schema: CronCreateInputSchema, name: "CronCreateInput" },
-  { schema: CronUpdateInputSchema, name: "CronUpdateInput" },
+  { schema: CronSchema, name: 'Cron' },
+  { schema: CronCreateInputSchema, name: 'CronCreateInput' },
+  { schema: CronUpdateInputSchema, name: 'CronUpdateInput' },
 
   // Domain
-  { schema: DomainSchema, name: "Domain" },
-  { schema: DomainCreateInputSchema, name: "DomainCreateInput" },
+  { schema: DomainSchema, name: 'Domain' },
+  { schema: DomainCreateInputSchema, name: 'DomainCreateInput' },
 
   // Worker
-  { schema: WorkerSchema, name: "Worker" },
-  { schema: WorkerCreateInputSchema, name: "WorkerCreateInput" },
-  { schema: WorkerUpdateInputSchema, name: "WorkerUpdateInput" },
-  { schema: WorkerLanguageSchema, name: "WorkerLanguage" },
+  { schema: WorkerSchema, name: 'Worker' },
+  { schema: WorkerCreateInputSchema, name: 'WorkerCreateInput' },
+  { schema: WorkerUpdateInputSchema, name: 'WorkerUpdateInput' },
+  { schema: WorkerLanguageSchema, name: 'WorkerLanguage' }
 ];
 
 async function generateTypes() {
-  console.log("🔄 Generating TypeScript types from Zod schemas...");
+  console.log('🔄 Generating TypeScript types from Zod schemas...');
 
   // Clean dist directory
   const distDir = `${import.meta.dir}/../dist`;
-  console.log("  🧹 Cleaning dist directory...");
+  console.log('  🧹 Cleaning dist directory...');
   try {
     await Bun.$`rm -rf ${distDir}`;
   } catch (error) {
@@ -111,30 +92,28 @@ async function generateTypes() {
   let idCounter = 0;
   const auxiliaryTypeStore = {
     nextId: () => `T${idCounter++}`,
-    definitions: new Map(),
+    definitions: new Map()
   };
 
-  console.log("  📋 First pass: building types map...");
+  console.log('  📋 First pass: building types map...');
   for (const { schema, name } of schemas) {
     try {
       const { node } = zodToTs(schema, { auxiliaryTypeStore });
       let typeStr = printNode(node);
       // Normalize whitespace for better matching
-      typeStr = typeStr.replace(/\s+/g, " ").trim();
+      typeStr = typeStr.replace(/\s+/g, ' ').trim();
       typesMap.set(typeStr, name);
     } catch (error) {
       console.error(`❌ Failed to generate type for ${name}:`, error);
     }
   }
 
   // SECOND PASS: Replace nested types with references
-  console.log("  🔄 Second pass: replacing nested types...");
+  console.log('  🔄 Second pass: replacing nested types...');
   const finalTypesMap = new Map<string, string>();
 
   // Sort types by length (longest first) for better matching
-  const sortedTypes = Array.from(typesMap.entries()).sort(
-    ([a], [b]) => b.length - a.length
-  );
+  const sortedTypes = Array.from(typesMap.entries()).sort(([a], [b]) => b.length - a.length);
 
   for (const [typeStr, name] of typesMap) {
     let updatedTypeStr = typeStr;
@@ -143,18 +122,15 @@ async function generateTypes() {
     for (const [otherTypeStr, otherName] of sortedTypes) {
       if (otherName !== name && updatedTypeStr.includes(otherTypeStr)) {
         // Use a more precise replacement to avoid partial matches
-        updatedTypeStr = updatedTypeStr.replaceAll(
-          otherTypeStr,
-          `I${otherName}`
-        );
+        updatedTypeStr = updatedTypeStr.replaceAll(otherTypeStr, `I${otherName}`);
       }
     }
 
     finalTypesMap.set(name, updatedTypeStr);
   }
 
   // THIRD PASS: Recursive replacement until no more changes
-  console.log("  🔁 Third pass: recursive replacement...");
+  console.log('  🔁 Third pass: recursive replacement...');
   let changed = true;
   let iterations = 0;
   const maxIterations = 10;
@@ -168,10 +144,7 @@ async function generateTypes() {
 
       for (const [otherTypeStr, otherName] of sortedTypes) {
         if (otherName !== name && updatedTypeStr.includes(otherTypeStr)) {
-          const newStr = updatedTypeStr.replaceAll(
-            otherTypeStr,
-            `I${otherName}`
-          );
+          const newStr = updatedTypeStr.replaceAll(otherTypeStr, `I${otherName}`);
           if (newStr !== updatedTypeStr) {
             updatedTypeStr = newStr;
             changed = true;
@@ -214,46 +187,43 @@ export type Dictionary<T> = Record<string, T>;
   }
 
   // Format with prettier
-  console.log("  🎨 Formatting with prettier...");
+  console.log('  🎨 Formatting with prettier...');
   const formatted = await prettier.format(output, {
-    parser: "typescript",
+    parser: 'typescript',
     semi: true,
     singleQuote: true,
-    trailingComma: "all",
+    trailingComma: 'all'
   });
 
   // Write types file
   await Bun.write(`${distDir}/types.d.ts`, formatted);
 
   // Generate package.json for npm publish
   const packageJson = {
-    name: "@openworkers/api-types",
+    name: '@openworkers/api-types',
     version,
-    license: "MIT",
-    type: "module",
+    license: 'MIT',
+    type: 'module',
     private: false,
-    main: "./types.d.ts",
-    types: "./types.d.ts",
+    main: './types.d.ts',
+    types: './types.d.ts',
     exports: {
-      ".": "./types.d.ts",
+      '.': './types.d.ts'
     },
-    description: "TypeScript types for OpenWorkers API",
-    keywords: ["openworkers", "types", "typescript"],
+    description: 'TypeScript types for OpenWorkers API',
+    keywords: ['openworkers', 'types', 'typescript'],
     repository: {
-      type: "git",
-      url: "git+https://github.com/openworkers/openworkers-api.git",
+      type: 'git',
+      url: 'git+https://github.com/openworkers/openworkers-api.git'
     },
     publishConfig: {
-      access: "public",
-      registry: "https://registry.npmjs.org/",
-      provenance: true,
-    },
+      access: 'public',
+      registry: 'https://registry.npmjs.org/',
+      provenance: true
+    }
   };
 
-  await Bun.write(
-    `${distDir}/package.json`,
-    JSON.stringify(packageJson, null, 2)
-  );
+  await Bun.write(`${distDir}/package.json`, JSON.stringify(packageJson, null, 2));
 
   // Copy LICENSE
   const license = await Bun.file(`${import.meta.dir}/../LICENSE`).text();

server.ts

@@ -11,16 +11,16 @@
  * For development, use `bun --hot src/index.ts` which relies on
  * the default export and lets Bun handle hot reload lifecycle.
  */
-import app from "./src";
+import app from './src';
 
 const server = Bun.serve(app);
 
-process.on("SIGTERM", () => {
-  console.log("SIGTERM received, shutting down gracefully...");
+process.on('SIGTERM', () => {
+  console.log('SIGTERM received, shutting down gracefully...');
   server.stop(true);
 });
 
-process.on("SIGINT", () => {
-  console.log("SIGINT received, shutting down gracefully...");
+process.on('SIGINT', () => {
+  console.log('SIGINT received, shutting down gracefully...');
   server.stop(true);
 });