wip

Author: gameroman

package.json

@@ -10,7 +10,7 @@
     "gen": "bun run gen:schemas && bun run gen:client && bun run format",
     "test": "bun test",
     "typecheck": "tsc --noEmit",
-    "format": "biome format --write",
+    "format": "biome check --write --linter-enabled=false",
     "build": "bunx --bun tsdown",
     "prepublishOnly": "bun run build"
   },
@@ -32,8 +32,6 @@
     "@typescript/native-preview": "^7.0.0-dev.20260124.1",
     "tsdown": "^0.20.1"
   },
-  "main": "./dist/index.mjs",
-  "module": "./dist/index.mjs",
   "types": "./dist/index.d.mts",
   "exports": {
     ".": "./dist/index.mjs",

scripts/gen-client.ts

@@ -1,14 +1,14 @@
 import * as z from "zod";
 
 import {
-  SchemaSchemaRef,
-  SchemaSchema,
-  convertToZod,
-  Primitive,
-  SchemaSchemaPrimitive,
-  SchemaSchemaBoolean,
   assertNever,
+  convertToZod,
+  OperationParameterBase,
   type Schema,
+  SchemaSchema,
+  SchemaSchemaBoolean,
+  SchemaSchemaPrimitive,
+  SchemaSchemaRef,
 } from "./shared";
 
 const Semver = z.string().brand("Semver");
@@ -21,9 +21,7 @@ const OpenApiSchemaInfo = z.object({
     url: z.url(),
     email: z.email(),
   }),
-  "x-logo": z.object({
-    url: z.url(),
-  }),
+  "x-logo": z.object({ url: z.url() }),
   license: z.object({
     name: z.string(),
     url: z.url(),
@@ -90,13 +88,11 @@ const OAuth2Schema = z.tuple([z.object({ OAuth2: z.array(OAuth2Scope) })]);
 const SecuritySchema = z.union([z.array(AccessTokenScopeSchema), OAuth2Schema]);
 
 const StringJsonRef = z
-  .string()
-  .refine((str) => str.endsWith(".json"))
+  .templateLiteral([z.string(), ".json"])
   .brand("StringJsonRef");
 
 const SchemaSchemaExampleRef = z
-  .object({ $ref: StringJsonRef })
-  .strict()
+  .strictObject({ $ref: StringJsonRef })
   .transform((s) => ({ ...s, __schema: "$ref" as const }));
 
 const ResponseContentBaseContent = z.object({
@@ -124,37 +120,34 @@ const ResponseContentChessPgnContent = ResponseContentBaseContent.extend({})
 const ResponseContentJson = z
   .union([
     z
-      .object({ "application/json": ResponseContentJsonContent })
-      .strict()
+      .strictObject({ "application/json": ResponseContentJsonContent })
       .transform((x) => x["application/json"]),
     z
-      .object({ "application/vnd.lichess.v3+json": ResponseContentJsonContent })
-      .strict()
+      .strictObject({
+        "application/vnd.lichess.v3+json": ResponseContentJsonContent,
+      })
       .transform((x) => x["application/vnd.lichess.v3+json"]),
   ])
   .transform((x) => ({ ...x, __content_type: "json" as const }));
 
 const ResponseContentNdjson = z
-  .object({ "application/x-ndjson": ResponseContentNdjsonContent })
-  .strict()
+  .strictObject({ "application/x-ndjson": ResponseContentNdjsonContent })
   .transform((x) => x["application/x-ndjson"])
   .transform((x) => ({ ...x, __content_type: "ndjson" as const }));
 
 const ResponseContentChessPgn = z
-  .object({ "application/x-chess-pgn": ResponseContentChessPgnContent })
-  .strict()
+  .strictObject({ "application/x-chess-pgn": ResponseContentChessPgnContent })
   .transform((x) => x["application/x-chess-pgn"])
   .transform((x) => ({ ...x, __content_type: "chess-pgn" as const }));
 
 const ResponseContentMixed = z
-  .object({
+  .strictObject({
     "text/plain": ResponseContextPlainTextContent.optional(),
     "application/json": ResponseContentJsonContent.optional(),
     "application/vnd.lichess.v3+json": ResponseContentJsonContent.optional(),
     "application/x-chess-pgn": ResponseContentChessPgnContent.optional(),
     "application/x-ndjson": ResponseContentNdjsonContent.optional(),
   })
-  .strict()
   .transform((x) => ({ ...x, __content_type: "mixed" as const }));
 
 const ResponseContentNoContent = z
@@ -170,50 +163,34 @@ const ResponseContent = z.union([
 ]);
 type ResponseCaseContent = z.infer<typeof ResponseContent>;
 
-const ResponseSchemaHeaders = z
-  .object({
-    "Access-Control-Allow-Origin": z
-      .object({
-        schema: z.object({
-          type: z.literal("string"),
-          default: z.literal("'*'"),
-        }),
-      })
-      .strict(),
-    "Last-Modified": z
-      .object({
-        schema: z.object({
-          type: z.literal("string"),
-          example: z.string(),
-        }),
-      })
-      .strict()
-      .optional(),
-  })
-  .strict();
+const ResponseSchemaHeaders = z.strictObject({
+  "Access-Control-Allow-Origin": z.strictObject({
+    schema: z.object({
+      type: z.literal("string"),
+      default: z.literal("'*'"),
+    }),
+  }),
+  "Last-Modified": z
+    .strictObject({
+      schema: z.object({
+        type: z.literal("string"),
+        example: z.string(),
+      }),
+    })
+    .optional(),
+});
 
-const ResponseSchema = z
-  .object({
-    description: z.string(),
-    headers: ResponseSchemaHeaders.optional(),
-    content: ResponseContent,
-  })
-  .strict();
+const ResponseSchema = z.strictObject({
+  description: z.string(),
+  headers: ResponseSchemaHeaders.optional(),
+  content: ResponseContent,
+});
 type ResponseCase = z.infer<typeof ResponseSchema>;
 
-const OperationParameterBase = z
-  .object({
-    name: z.string(),
-    description: z.string().optional(),
-    example: Primitive.optional(),
-  })
-  .strict();
-
 const SchemaSchemaNullableRefToPrimitive = z
-  .object({
+  .strictObject({
     allOf: z.tuple([SchemaSchemaRef, z.object({ default: z.null() })]),
   })
-  .strict()
   .transform((s) => ({
     ...s,
     __schema: "notverified:reftoprimitive:nullable" as const,
@@ -225,25 +202,22 @@ const SchemaSchemaRefToPrimitive = SchemaSchemaRef.brand(
 ).transform((s) => ({ ...s, __schema: "notverified:reftoprimitive" as const }));
 
 const SchemaSchemaBooleanLike = z
-  .object({
+  .strictObject({
     anyOf: z.tuple([
       SchemaSchemaBoolean,
       z.object({ type: z.literal("string"), const: z.literal("yes") }),
     ]),
     example: z.literal("yes"),
   })
-  .strict()
   .transform((s) => ({ ...s, __schema: "boolean-like" as const }))
   .brand("SchemaSchemaBooleanLike");
 
 const SchemaSchemaArrayOfPrimitive = z
-  .object({ type: z.literal("array"), items: SchemaSchemaPrimitive })
-  .strict()
+  .strictObject({ type: z.literal("array"), items: SchemaSchemaPrimitive })
   .transform((s) => ({ ...s, __schema: "array:primitive" as const }));
 
 const SchemaSchemaArrayOfRefToPrimitive = z
-  .object({ type: z.literal("array"), items: SchemaSchemaRefToPrimitive })
-  .strict()
+  .strictObject({ type: z.literal("array"), items: SchemaSchemaRefToPrimitive })
   .transform((s) => ({
     ...s,
     __schema: "array:notverified:reftoprimitive" as const,
@@ -315,20 +289,17 @@ const BaseTagSchemaOperation = z.object({
 });
 
 const RequestBodyContentJson = z
-  .object({ "application/json": z.object({ schema: SchemaSchema }) })
-  .strict()
+  .strictObject({ "application/json": z.object({ schema: SchemaSchema }) })
   .transform((s) => ({ ...s, __type: "json" as const }));
 
 const RequestBodyContentPlainText = z
-  .object({ "text/plain": z.object({ schema: SchemaSchema }) })
-  .strict()
+  .strictObject({ "text/plain": z.object({ schema: SchemaSchema }) })
   .transform((s) => ({ ...s, __type: "text/plain" as const }));
 
 const RequestBodyContentWebFormUrlEncoded = z
-  .object({
+  .strictObject({
     "application/x-www-form-urlencoded": z.object({ schema: SchemaSchema }),
   })
-  .strict()
   .transform((s) => ({ ...s, __type: "x-www-form-urlencoded" as const }));
 
 const RequestBodyContent = z.union([
@@ -337,13 +308,11 @@ const RequestBodyContent = z.union([
   RequestBodyContentWebFormUrlEncoded,
 ]);
 
-const RequestBodySchema = z
-  .object({
-    description: z.string().optional(),
-    required: z.boolean().optional(),
-    content: RequestBodyContent,
-  })
-  .strict();
+const RequestBodySchema = z.strictObject({
+  description: z.string().optional(),
+  required: z.boolean().optional(),
+  content: RequestBodyContent,
+});
 
 const TagSchemaSchemaGet = BaseTagSchemaOperation.extend({})
   .strict()
@@ -821,7 +790,6 @@ function processTag(tagSchema: TagSchema, rawApiPath: string) {
       sharedPathParams,
       baseUrl,
     });
-    console.log(processedOperation);
     if (processedOperation.__type === "__parameters") {
       sharedPathParams = processedOperation.parameters;
     }
@@ -843,7 +811,6 @@ async function processSchema(schema: OpenApiSchema): Promise<void> {
     const fullYamlPath = `${tagsDir}/${tagPath}` as const;
     const yamlStr = await Bun.file(fullYamlPath).text();
     const schema = Bun.YAML.parse(yamlStr);
-    console.log({ fullYamlPath, schema });
     const tagSchema = TagSchemaSchema.parse(schema);
     const newMethods = processTag(tagSchema, rawApiPath);
     methodsCode.push(...newMethods);
@@ -855,10 +822,10 @@ async function processSchema(schema: OpenApiSchema): Promise<void> {
 
   const clientCodeTs = `import * as z from "zod";
 
-import * as schemas from "~/schemas";
-
 import { ndjsonStream } from "~/lib/ndjson";
 
+import * as schemas from "~/schemas";
+
 import { Requestor } from "./requestor";
 
 export const BASE_URL = "${API_URL}";
@@ -883,11 +850,13 @@ export class Lichess {
 }
 
 async function main() {
+  console.log("Generating client...");
   const filePath = "specs/lichess-api.yaml" as const;
   const yamlStr = await Bun.file(filePath).text();
   const yamlContent = Bun.YAML.parse(yamlStr);
   const parsedSchema = OpenApiSchemaSchema.parse(yamlContent);
   await processSchema(parsedSchema);
+  console.log("Client generated");
 }
 
 await main();

scripts/gen-schemas.ts

@@ -1,9 +1,8 @@
-import { convertToZod, SchemaSchema } from "./shared";
-
 import { readdirSync } from "node:fs";
-import path from "node:path";
 import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { prettifyError } from "zod/mini";
+import { convertToZod, SchemaSchema } from "./shared";
 
 async function processFile(filePath: string) {
   const normalizedFilePath = filePath.replaceAll("\\", "/");
@@ -18,8 +17,8 @@ async function processFile(filePath: string) {
   }
   const { zodSchema, refs: uniqueRefs } = convertToZod(parsedSchema.data);
 
-  uniqueRefs.sort();
   const refImports = uniqueRefs
+    .toSorted()
     .map((refName) => `import { ${refName} } from "./${refName}";` as const)
     .join("\n");
   const spacedRefImports = refImports
@@ -48,8 +47,8 @@ async function main() {
   const schemasDir = "specs/schemas" as const;
   const glob = new Bun.Glob(`${schemasDir}/*.{yaml}` as const);
   const yamlFiles = await Array.fromAsync(glob.scan());
-  const filesToProcess = yamlFiles.filter((f) => !f.includes("_index.yaml"));
-  for (const fullPath of filesToProcess) {
+  for (const fullPath of yamlFiles) {
+    if (fullPath.includes("_index.yaml")) continue;
     await processFile(fullPath);
   }
   const tsFiles = readdirSync(outDir)

scripts/shared.ts

@@ -161,6 +161,12 @@ const SchemaSchemaAnyOf = BaseSchema.extend({
   .strict()
   .transform((s) => ({ ...s, __schema: "anyOf" as const }));
 
+export const OperationParameterBase = z.strictObject({
+  name: z.string(),
+  description: z.string().optional(),
+  example: Primitive.optional(),
+});
+
 const SchemaSchema = z.union([
   SchemaSchemaRef,
   SchemaSchemaNull,

src/client/index.ts

@@ -1,9 +1,9 @@
 import * as z from "zod";
 
-import * as schemas from "~/schemas";
-
 import { ndjsonStream } from "~/lib/ndjson";
 
+import * as schemas from "~/schemas";
+
 import { Requestor } from "./requestor";
 
 export const BASE_URL = "https://lichess.org";

src/schemas/index.ts

@@ -103,8 +103,8 @@ export { OpponentGoneEvent } from "./OpponentGoneEvent";
 export { Patron } from "./Patron";
 export { PatronColor } from "./PatronColor";
 export { Perf } from "./Perf";
-export { Perfs } from "./Perfs";
 export { PerfStat } from "./PerfStat";
+export { Perfs } from "./Perfs";
 export { PerfTop10 } from "./PerfTop10";
 export { PerfType } from "./PerfType";
 export { PlayTime } from "./PlayTime";
@@ -118,8 +118,8 @@ export { PuzzleDashboard } from "./PuzzleDashboard";
 export { PuzzleGlicko } from "./PuzzleGlicko";
 export { PuzzleModePerf } from "./PuzzleModePerf";
 export { PuzzlePerformance } from "./PuzzlePerformance";
-export { PuzzleRacer } from "./PuzzleRacer";
 export { PuzzleRaceResults } from "./PuzzleRaceResults";
+export { PuzzleRacer } from "./PuzzleRacer";
 export { PuzzleReplay } from "./PuzzleReplay";
 export { PuzzleStormDashboard } from "./PuzzleStormDashboard";
 export { RatingHistory } from "./RatingHistory";

tests/index.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "bun:test";
+import { describe, expect, it } from "bun:test";
 
 import { Lichess } from "@lichess/api";