Gen api types

Author: max-lt

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 OpenWorkers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

bun.lock

@@ -1,22 +1,26 @@
 {
   "name": "openworkers-api",
   "version": "1.0.0",
+  "license": "MIT",
   "module": "src/index.ts",
   "type": "module",
   "private": true,
   "scripts": {
     "dev": "bun --hot src/index.ts",
     "start": "bun src/index.ts",
     "compile": "bun build --compile --minify --sourcemap server.ts --outfile dist/openworkers-api",
-    "test": "bun test"
+    "test": "bun test",
+    "generate-types": "bun scripts/generate-types.ts"
   },
   "dependencies": {
     "@openworkers/croner-wasm": "^0.3.0",
     "hono": "^4.10.6",
     "zod": "^4.1.12"
   },
   "devDependencies": {
-    "@types/bun": "latest"
+    "@types/bun": "latest",
+    "prettier": "^3.6.2",
+    "zod-to-ts": "^2.0.0"
   },
   "peerDependencies": {
     "typescript": "^5"

package.json

@@ -0,0 +1,263 @@
+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
+  );
+  return printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);
+}
+
+// Import all schemas
+import {
+  ResourceSchema,
+  TimestampsSchema,
+} from "../src/types/schemas/base.schema";
+
+import { LoginResponseSchema } from "../src/types/schemas/auth.schema";
+
+import {
+  SelfSchema,
+  ResourceLimitsSchema,
+} from "../src/types/schemas/user.schema";
+
+import {
+  EnvironmentSchema,
+  EnvironmentCreateInputSchema,
+  EnvironmentUpdateInputSchema,
+  EnvironmentValueSchema,
+  EnvironmentValueUpdateInputSchema,
+} from "../src/types/schemas/environment.schema";
+
+import {
+  CronSchema,
+  CronCreateInputSchema,
+  CronUpdateInputSchema,
+} from "../src/types/schemas/cron.schema";
+
+import {
+  DomainSchema,
+  DomainCreateInputSchema,
+} from "../src/types/schemas/domain.schema";
+
+import {
+  WorkerSchema,
+  WorkerCreateInputSchema,
+  WorkerUpdateInputSchema,
+  WorkerLanguageSchema,
+} from "../src/types/schemas/worker.schema";
+
+// Schema definitions to generate
+const schemas = [
+  // Base schemas
+  { schema: ResourceSchema, name: "Resource" },
+  { schema: TimestampsSchema, name: "Timestamps" },
+
+  // Auth
+  { schema: LoginResponseSchema, name: "LoginResponse" },
+
+  // User
+  { 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: EnvironmentValueUpdateInputSchema,
+    name: "EnvironmentValueUpdateInput",
+  },
+
+  // Cron
+  { schema: CronSchema, name: "Cron" },
+  { schema: CronCreateInputSchema, name: "CronCreateInput" },
+  { schema: CronUpdateInputSchema, name: "CronUpdateInput" },
+
+  // Domain
+  { 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" },
+];
+
+async function generateTypes() {
+  console.log("🔄 Generating TypeScript types from Zod schemas...");
+
+  // Clean dist directory
+  const distDir = `${import.meta.dir}/../dist`;
+  console.log("  🧹 Cleaning dist directory...");
+  try {
+    await Bun.$`rm -rf ${distDir}`;
+  } catch (error) {
+    // Ignore error if dist doesn't exist
+  }
+
+  // FIRST PASS: Generate all types and build a map
+  const typesMap = new Map<string, string>();
+  let idCounter = 0;
+  const auxiliaryTypeStore = {
+    nextId: () => `T${idCounter++}`,
+    definitions: new 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();
+      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...");
+  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
+  );
+
+  for (const [typeStr, name] of typesMap) {
+    let updatedTypeStr = typeStr;
+
+    // Replace all occurrences of other types with their names (with I prefix)
+    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}`
+        );
+      }
+    }
+
+    finalTypesMap.set(name, updatedTypeStr);
+  }
+
+  // THIRD PASS: Recursive replacement until no more changes
+  console.log("  🔁 Third pass: recursive replacement...");
+  let changed = true;
+  let iterations = 0;
+  const maxIterations = 10;
+
+  while (changed && iterations < maxIterations) {
+    changed = false;
+    iterations++;
+
+    for (const [name, typeStr] of finalTypesMap) {
+      let updatedTypeStr = typeStr;
+
+      for (const [otherTypeStr, otherName] of sortedTypes) {
+        if (otherName !== name && updatedTypeStr.includes(otherTypeStr)) {
+          const newStr = updatedTypeStr.replaceAll(
+            otherTypeStr,
+            `I${otherName}`
+          );
+          if (newStr !== updatedTypeStr) {
+            updatedTypeStr = newStr;
+            changed = true;
+          }
+        }
+      }
+
+      if (updatedTypeStr !== typeStr) {
+        finalTypesMap.set(name, updatedTypeStr);
+      }
+    }
+  }
+
+  console.log(`  ✓ Completed in ${iterations} iteration(s)`);
+
+  // Generate output
+  let output = `/**
+ * Auto-generated TypeScript types from Zod schemas
+ * DO NOT EDIT THIS FILE MANUALLY
+ * Generated on: ${new Date().toISOString()}
+ */
+
+`;
+
+  // Add global types
+  output += `// Global types
+export type hex = string;
+export type uuid = string;
+export type timestamp = number;
+export type Dictionary<T> = Record<string, T>;
+
+`;
+
+  // Add all final types with "I" prefix
+  for (const { name } of schemas) {
+    const typeStr = finalTypesMap.get(name);
+    if (typeStr) {
+      output += `export type I${name} = ${typeStr};\n\n`;
+    }
+  }
+
+  // Format with prettier
+  console.log("  🎨 Formatting with prettier...");
+  const formatted = await prettier.format(output, {
+    parser: "typescript",
+    semi: true,
+    singleQuote: true,
+    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",
+    version: "1.0.0",
+    license: "MIT",
+    type: "module",
+    private: false,
+    main: "./types.d.ts",
+    types: "./types.d.ts",
+    exports: {
+      ".": "./types.d.ts",
+    },
+    description: "TypeScript types for OpenWorkers API",
+    keywords: ["openworkers", "types", "typescript"],
+    repository: {
+      type: "git",
+      url: "https://github.com/openworkers/openworkers-api",
+    },
+    publishConfig: {
+      access: "public",
+    },
+  };
+
+  await Bun.write(
+    `${distDir}/package.json`,
+    JSON.stringify(packageJson, null, 2)
+  );
+
+  // Copy LICENSE
+  const license = await Bun.file(`${import.meta.dir}/../LICENSE`).text();
+  await Bun.write(`${distDir}/LICENSE`, license);
+
+  console.log(`✅ Types package generated successfully`);
+  console.log(`   📦 Run "cd dist && npm publish" to publish`);
+}
+
+generateTypes().catch(console.error);

scripts/generate-types.ts

@@ -10,7 +10,7 @@ import environments from "./routes/environments";
 import domains from "./routes/domains";
 import pkg from "../package.json";
 
-const app = new Hono();
+export const app = new Hono();
 
 // Global middlewares
 app.use("*", logger());