@specbook/codegen 0.4.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specbook/codegen",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Turns an OpenAPI or Swagger document into types, examples, schemas and metadata, in Node or in a browser.",
   "keywords": [
     "specbook",
@@ -40,7 +40,7 @@
     "swagger2openapi": "7.0.8"
   },
   "devDependencies": {
-    "@specbook/core": "0.4.0",
+    "@specbook/core": "0.5.0",
     "@types/node": "24.19.2",
     "@types/swagger2openapi": "7.0.4",
     "typescript": "7.0.2"

package/src/build.ts

@@ -397,17 +397,16 @@ export function generateFromDoc(
           if (defaultType) responseTypes.push(`${st}: ${defaultType}`)
         }
       }
-      // ---- request examples: spec-defined first, then generated default and dynamic
+      // ---- request examples: spec-defined first, then the generated default
       const fileFieldPaths = body?.encoding === 'multipart' ? fileFields(body.schema, resolve) : []
       const wholeBodyFile = body?.encoding === 'binary'
       const sample = `./${SAMPLE_FILE}`
-      const paramsFor = (fake: boolean) => {
+      const paramsFor = () => {
         const pick = (where: string) => {
           const out: Record<string, unknown> = {}
           for (const p of group(where)) {
             if (p.example !== undefined) out[p.name] = p.example
-            else if (p.required)
-              out[p.name] = synthesize(p.schema, resolve, 0, [], p.name, undefined, fake)
+            else if (p.required) out[p.name] = synthesize(p.schema, resolve, 0, [], p.name)
           }
           return Object.keys(out).length ? out : undefined
         }
@@ -433,7 +432,7 @@ export function generateFromDoc(
           title: ex.summary ?? key,
           summary: ex.description,
           source: 'spec',
-          ...paramsFor(false),
+          ...paramsFor(),
           body: bodyFor(sanitizeExample(ex.value)),
         })
       }
@@ -442,30 +441,16 @@ export function generateFromDoc(
           name: take('example'),
           title: 'Example',
           source: 'spec',
-          ...paramsFor(false),
+          ...paramsFor(),
           body: bodyFor(sanitizeExample(body.media.example)),
         })
       const plain = {
-        ...paramsFor(false),
+        ...paramsFor(),
         body: body?.schema
-          ? bodyFor(synthesize(body.schema, resolve, 0, [], '', undefined, false, true))
-          : undefined,
-      }
-      const dynamic = {
-        ...paramsFor(true),
-        body: body?.schema
-          ? bodyFor(synthesize(body.schema, resolve, 0, [], '', undefined, true, true))
+          ? bodyFor(synthesize(body.schema, resolve, 0, [], '', undefined, true))
           : undefined,
       }
       docs.push({ name: take('default'), title: 'Default', source: 'generated', ...plain })
-      if (JSON.stringify(dynamic) !== JSON.stringify(plain))
-        docs.push({
-          name: take('dynamic'),
-          title: 'Dynamic',
-          summary: 'Generated values, fresh on every play.',
-          source: 'generated',
-          ...dynamic,
-        })
       for (const d of docs)
         exampleFiles.push({
           path: `examples/${id}/${d.name}.example.json`,

package/src/schema.ts

@@ -247,41 +247,6 @@ function exampleBoolean(key: string): boolean {
   )
 }
 
-const FAKE_BY_FORMAT: Record<string, string> = {
-  email: 'internet.email',
-  uuid: 'string.uuid',
-  uri: 'internet.url',
-  url: 'internet.url',
-  hostname: 'internet.domainName',
-  ipv4: 'internet.ipv4',
-}
-
-const FAKE_BY_NAME: [RegExp, string][] = [
-  [/^(first_?name|given_?name)$/, 'person.firstName'],
-  [/^(last_?name|family_?name|surname)$/, 'person.lastName'],
-  [/^(full_?name|display_?name)$/, 'person.fullName'],
-  [/^name$/, 'word.noun'],
-  [/^(user_?name|login|handle)$/, 'internet.username'],
-  [/^e?-?mail(_?address)?$/, 'internet.email'],
-  [/^(phone|phone_?number|mobile)$/, 'phone.number'],
-  [/^(city|town)$/, 'location.city'],
-  [/^country$/, 'location.country'],
-  [/^(postal_?code|zip|zip_?code)$/, 'location.zipCode'],
-  [/^(line1|address|street|address_?line_?1)$/, 'location.streetAddress'],
-  [/^(company|organization|org)$/, 'company.name'],
-  [/^(title|subject)$/, 'lorem.sentence'],
-  [/^(description|summary|bio|about|body|comment|note|notes|message)$/, 'lorem.sentence'],
-  [/^(url|website|homepage)$/, 'internet.url'],
-]
-
-/** `{{faker.*}}` placeholder for a string leaf, chosen by format first and then by field name. */
-export function fakerFor(key: string, format?: string): string | undefined {
-  const path =
-    (format && FAKE_BY_FORMAT[format]) ||
-    FAKE_BY_NAME.find(([re]) => re.test(key.toLowerCase()))?.[1]
-  return path ? `{{faker.${path}}}` : undefined
-}
-
 /** Deepest nesting of objects and arrays an example goes into before it settles for an empty one. */
 const MAX_DEPTH = 6
 
@@ -351,22 +316,17 @@ export function synthesize(
   seen: string[] = [],
   key = '',
   status?: number,
-  fake = false,
   sparse = false,
 ): unknown {
   if (!schema) return null
   const again = (s: Schema | undefined, k = key, d = depth, sn = seen) =>
-    synthesize(s, resolve, d, sn, k, status, fake, sparse)
+    synthesize(s, resolve, d, sn, k, status, sparse)
   if (schema.$ref) {
     const target = resolve(schema.$ref)
     // a reference back into itself carries on as "required fields only", which the depth rules then end
     if (seen.includes(schema.$ref)) return again(target, key, Math.max(depth, MAX_DEPTH), [])
     return again(target, key, depth, [...seen, schema.$ref])
   }
-  if (fake && schema.type === 'string' && !schema.enum) {
-    const generated = fakerFor(key, schema.format)
-    if (generated) return generated
-  }
   // a spec example that contradicts its own schema (a string field whose example is an array) is ignored
   if (schema.example !== undefined && fits(schema, schema.example))
     return schema.enum