ci

Author: soyuka

.github/workflows/ci.yml

@@ -0,0 +1,25 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+  pull_request: ~
+
+jobs:
+  ci:
+    name: Lint and test
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: "current"
+      - name: Install dependencies
+        run: npm install
+      - name: Check formatting
+        run: npm run lint
+      - name: Run tests
+        run: npm test

.github/workflows/release.yml

@@ -0,0 +1,30 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+  workflow_dispatch: ~
+
+permissions:
+  id-token: write
+  contents: read
+
+jobs:
+  release:
+    name: Create and publish a release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: "current"
+          registry-url: https://registry.npmjs.org
+      - name: Install dependencies
+        run: npm install
+      - name: Run tests
+        run: npm test
+      - name: Publish to npm
+        run: npm publish --provenance --access public

.gitignore

@@ -0,0 +1 @@
+node_modules

README.md

@@ -15,19 +15,19 @@ Requires Zod v4.
 ## Quick Start
 
 ```js
-import { createSchemas } from '@api-platform/zod'
-import { safeParse } from 'zod/v4'
+import { createSchemas } from "@api-platform/zod";
+import { safeParse } from "zod/v4";
 
 // Generate schemas from an API entrypoint
-const { schemas, collections } = await createSchemas('https://api.example.com')
+const { schemas, collections } = await createSchemas("https://api.example.com");
 
 // schemas.Book -> z.looseObject({ '@id': z.string(), '@type': z.literal('Book'), title: z.string(), ... })
 // collections.Book -> Hydra collection schema wrapping Book
 
 // Validate API responses
-const result = safeParse(schemas.Book, responseData)
+const result = safeParse(schemas.Book, responseData);
 if (result.success) {
-  console.log(result.data.title)
+  console.log(result.data.title);
 }
 ```
 
@@ -38,14 +38,18 @@ if (result.success) {
 High-level function that fetches and parses API documentation, then generates Zod schemas.
 
 ```js
-const { schemas, collections, resources, api, response } = await createSchemas('https://api.example.com')
+const { schemas, collections, resources, api, response } = await createSchemas(
+  "https://api.example.com",
+);
 ```
 
 **Parameters:**
+
 - `entrypoint` — The API entrypoint URL
 - `options` — Options passed to `parseHydraDocumentation`
 
 **Returns:**
+
 - `schemas` — `{ [ResourceName]: ZodSchema }` for each resource
 - `collections` — `{ [ResourceName]: ZodSchema }` Hydra collection schemas
 - `resources` — The parsed resource objects from api-doc-parser
@@ -57,59 +61,59 @@ const { schemas, collections, resources, api, response } = await createSchemas('
 Lower-level function that works with pre-parsed Resource objects (from api-doc-parser). Useful when you already have the parsed API documentation.
 
 ```js
-import { schemasFromResources } from '@api-platform/zod'
+import { schemasFromResources } from "@api-platform/zod";
 
-const { schemas, collections } = schemasFromResources(api.resources)
+const { schemas, collections } = schemasFromResources(api.resources);
 ```
 
 ### `resourceToSchema(resource, schemaMap?)`
 
 Converts a single api-doc-parser Resource into a `z.looseObject` schema with `@id`, `@type`, and all readable fields.
 
 ```js
-import { resourceToSchema } from '@api-platform/zod'
+import { resourceToSchema } from "@api-platform/zod";
 
-const bookSchema = resourceToSchema(bookResource)
+const bookSchema = resourceToSchema(bookResource);
 ```
 
 ### `fieldToZod(field, schemaMap?)`
 
 Converts a single api-doc-parser Field into a Zod type.
 
 ```js
-import { fieldToZod } from '@api-platform/zod'
+import { fieldToZod } from "@api-platform/zod";
 
-const zodType = fieldToZod(field)
+const zodType = fieldToZod(field);
 ```
 
 ### `collectionSchema(itemSchema)`
 
 Creates a Hydra collection schema wrapping the given item schema.
 
 ```js
-import { collectionSchema } from '@api-platform/zod'
+import { collectionSchema } from "@api-platform/zod";
 
-const booksCollectionSchema = collectionSchema(bookSchema)
+const booksCollectionSchema = collectionSchema(bookSchema);
 ```
 
 ## Type Mapping
 
-| Field Type | Zod Type |
-|---|---|
-| `string`, `password`, `byte`, `binary`, `hexBinary`, `base64Binary`, `duration` | `z.string()` |
-| `email` | `z.string().email()` |
-| `url` | `z.string().url()` |
-| `uuid` | `z.string().uuid()` |
-| `integer` | `z.int()` |
-| `positiveInteger` | `z.int().min(1)` |
-| `negativeInteger` | `z.int().max(-1)` |
-| `nonNegativeInteger` | `z.int().min(0)` |
-| `nonPositiveInteger` | `z.int().max(0)` |
-| `number`, `decimal`, `double`, `float` | `z.number()` |
-| `boolean` | `z.boolean()` |
-| `date` | `z.string().date()` |
-| `dateTime` | `z.string().datetime()` |
-| `time` | `z.string().time()` |
+| Field Type                                                                      | Zod Type                |
+| ------------------------------------------------------------------------------- | ----------------------- |
+| `string`, `password`, `byte`, `binary`, `hexBinary`, `base64Binary`, `duration` | `z.string()`            |
+| `email`                                                                         | `z.string().email()`    |
+| `url`                                                                           | `z.string().url()`      |
+| `uuid`                                                                          | `z.string().uuid()`     |
+| `integer`                                                                       | `z.int()`               |
+| `positiveInteger`                                                               | `z.int().min(1)`        |
+| `negativeInteger`                                                               | `z.int().max(-1)`       |
+| `nonNegativeInteger`                                                            | `z.int().min(0)`        |
+| `nonPositiveInteger`                                                            | `z.int().max(0)`        |
+| `number`, `decimal`, `double`, `float`                                          | `z.number()`            |
+| `boolean`                                                                       | `z.boolean()`           |
+| `date`                                                                          | `z.string().date()`     |
+| `dateTime`                                                                      | `z.string().datetime()` |
+| `time`                                                                          | `z.string().time()`     |
 
 ### Special Cases
 
@@ -127,11 +131,11 @@ Schemas use `z.looseObject()`, which allows unknown properties to pass through w
 ```js
 // Extra fields in the response are preserved, not stripped
 const result = safeParse(schemas.Book, {
-  '@id': '/api/books/1',
-  '@type': 'Book',
-  title: 'The Great Gatsby',
-  newFieldAddedLater: 'still available',
-})
+  "@id": "/api/books/1",
+  "@type": "Book",
+  title: "The Great Gatsby",
+  newFieldAddedLater: "still available",
+});
 // result.data.newFieldAddedLater === 'still available'
 ```
 

package-lock.json

@@ -8,7 +8,9 @@
     ".": "./src/index.js"
   },
   "scripts": {
-    "test": "node --experimental-vm-modules node_modules/.bin/jest"
+    "test": "node --experimental-vm-modules node_modules/.bin/jest",
+    "lint": "prettier --check .",
+    "format": "prettier --write ."
   },
   "peerDependencies": {
     "zod": "^4.0.0"
@@ -17,8 +19,9 @@
     "@api-platform/api-doc-parser": "^0.16.9"
   },
   "devDependencies": {
-    "zod": "^4.0.0",
+    "@jest/globals": "^30.0.0",
     "jest": "^30.0.0",
-    "@jest/globals": "^30.0.0"
+    "prettier": "^3.8.1",
+    "zod": "^4.0.0"
   }
 }

package.json

@@ -22,7 +22,7 @@ export function collectionSchema(itemSchema) {
         last: z.optional(z.string()),
         previous: z.optional(z.string()),
         next: z.optional(z.string()),
-      })
+      }),
     ),
     search: z.optional(
       z.looseObject({
@@ -36,10 +36,10 @@ export function collectionSchema(itemSchema) {
               variable: z.string(),
               property: z.optional(z.nullable(z.string())),
               required: z.optional(z.boolean()),
-            })
-          )
+            }),
+          ),
         ),
-      })
+      }),
     ),
   });
 }

src/collection.js

@@ -54,7 +54,7 @@ describe("fieldToZod", () => {
   it("maps uuid to z.string().uuid()", () => {
     const schema = fieldToZod(makeField({ type: "uuid" }));
     expect(
-      z.safeParse(schema, "550e8400-e29b-41d4-a716-446655440000").success
+      z.safeParse(schema, "550e8400-e29b-41d4-a716-446655440000").success,
     ).toBe(true);
     expect(z.safeParse(schema, "not-a-uuid").success).toBe(false);
   });
@@ -129,7 +129,7 @@ describe("fieldToZod", () => {
 
   it("handles reference fields as z.string()", () => {
     const schema = fieldToZod(
-      makeField({ reference: { name: "Author", title: "Author" } })
+      makeField({ reference: { name: "Author", title: "Author" } }),
     );
     expect(z.safeParse(schema, "/api/authors/1").success).toBe(true);
     expect(z.safeParse(schema, 123).success).toBe(false);
@@ -144,17 +144,17 @@ describe("fieldToZod", () => {
 
     const schema = fieldToZod(
       makeField({ embedded: { name: "Author", title: "Author" } }),
-      schemaMap
+      schemaMap,
     );
 
     expect(
-      z.safeParse(schema, { "@id": "/api/authors/1", name: "Jane" }).success
+      z.safeParse(schema, { "@id": "/api/authors/1", name: "Jane" }).success,
     ).toBe(true);
   });
 
   it("handles enum fields", () => {
     const schema = fieldToZod(
-      makeField({ enum: ["draft", "published", "archived"] })
+      makeField({ enum: ["draft", "published", "archived"] }),
     );
     expect(z.safeParse(schema, "draft").success).toBe(true);
     expect(z.safeParse(schema, "published").success).toBe(true);
@@ -169,16 +169,14 @@ describe("fieldToZod", () => {
   });
 
   it("handles optional fields (required === false)", () => {
-    const schema = fieldToZod(
-      makeField({ type: "string", required: false })
-    );
+    const schema = fieldToZod(makeField({ type: "string", required: false }));
     expect(z.safeParse(schema, "hello").success).toBe(true);
     expect(z.safeParse(schema, undefined).success).toBe(true);
   });
 
   it("handles array fields (maxCardinality !== 1)", () => {
     const schema = fieldToZod(
-      makeField({ type: "string", maxCardinality: null })
+      makeField({ type: "string", maxCardinality: null }),
     );
     expect(z.safeParse(schema, ["a", "b"]).success).toBe(true);
     expect(z.safeParse(schema, "a").success).toBe(false);
@@ -425,9 +423,7 @@ describe("schemasFromResources", () => {
 
   it("builds collection schemas that validate", () => {
     const resources = [
-      makeResource("Book", [
-        makeField({ name: "title", type: "string" }),
-      ]),
+      makeResource("Book", [makeField({ name: "title", type: "string" })]),
     ];
 
     const { collections } = schemasFromResources(resources);
@@ -436,9 +432,7 @@ describe("schemasFromResources", () => {
       "@id": "/api/books",
       "@type": "Collection",
       totalItems: 1,
-      member: [
-        { "@id": "/api/books/1", "@type": "Book", title: "Test" },
-      ],
+      member: [{ "@id": "/api/books/1", "@type": "Book", title: "Test" }],
     });
 
     expect(result.success).toBe(true);