@voxgig/apidef 3.6.0 → 3.8.0

package/src/transform/field.ts

@@ -4,7 +4,7 @@ import { each, getx } from 'jostraca'
 
 import type { TransformResult, Transform } from '../transform'
 
-import { validator, canonize } from '../utility'
+import { validator, canonize, inferFieldType, normalizeFieldName } from '../utility'
 
 import { KIT } from '../types'
 
@@ -84,9 +84,10 @@ function resolveOpFields(
 
   for (let fielddef of fielddefs) {
     const fieldname = (fielddef as any).key$ as string
+    const name = canonize(normalizeFieldName(fieldname))
     const mfield: ModelField = {
-      name: canonize(fieldname),
-      type: validator(fielddef.type),
+      name,
+      type: inferFieldType(name, validator(fielddef.type)),
       req: !!fielddef.required,
       op: {},
     }
@@ -147,16 +148,108 @@ function findFieldDefs(
     }
 
     each(fieldSets, (fieldSet: any) => {
+      const requiredNames: string[] = Array.isArray(fieldSet?.required)
+        ? fieldSet.required : []
       each(fieldSet?.properties, (property: any) => {
+        if (requiredNames.includes(property.key$)) {
+          property.required = true
+        }
         fielddefs.push(property)
       })
     })
   }
 
+  // Fallback: infer fields from example response data when no schema properties found
+  if (0 === fielddefs.length && opdef) {
+    const exampleFields = inferFieldsFromExamples(opdef)
+    for (const ef of exampleFields) {
+      fielddefs.push(ef)
+    }
+  }
+
   return fielddefs
 }
 
 
+function inferFieldsFromExamples(opdef: any): SchemaDef[] {
+  const example = findExampleObject(opdef)
+  if (null == example || 'object' !== typeof example || Array.isArray(example)) {
+    return []
+  }
+
+  const fielddefs: SchemaDef[] = []
+  for (const [key, value] of Object.entries(example)) {
+    const fielddef: any = {
+      key$: key,
+      type: inferTypeFromValue(value),
+    }
+    fielddefs.push(fielddef)
+  }
+  return fielddefs
+}
+
+
+function findExampleObject(opdef: any): any {
+  const responses = opdef.responses
+  if (null == responses) return null
+
+  const resdef = responses[200] ?? responses[201] ?? responses['200'] ?? responses['201']
+  if (null == resdef) return null
+
+  // OpenAPI 3.x: content.application/json.example
+  let example = getx(resdef, 'content "application/json" example')
+  if (null != example && 'object' === typeof example) return unwrapExample(example)
+
+  // OpenAPI 3.x: content.application/json.examples (named examples — take first)
+  const examples = getx(resdef, 'content "application/json" examples')
+  if (null != examples && 'object' === typeof examples) {
+    for (const val of Object.values(examples)) {
+      const ex = (val as any)?.value
+      if (null != ex && 'object' === typeof ex) return unwrapExample(ex)
+    }
+  }
+
+  // OpenAPI 3.x: content.application/json.schema.example
+  example = getx(resdef, 'content "application/json" schema example')
+  if (null != example && 'object' === typeof example) return unwrapExample(example)
+
+  // Swagger 2.0: response.example / response.examples.application/json
+  example = resdef.example
+  if (null != example && 'object' === typeof example) return unwrapExample(example)
+
+  example = getx(resdef, 'examples "application/json"')
+  if (null != example && 'object' === typeof example) return unwrapExample(example)
+
+  // Swagger 2.0: schema.example
+  example = getx(resdef, 'schema example')
+  if (null != example && 'object' === typeof example) return unwrapExample(example)
+
+  return null
+}
+
+
+// If the example is a wrapper with a single array property, unwrap to the first item
+function unwrapExample(example: any): any {
+  if (Array.isArray(example)) {
+    return example.length > 0 ? example[0] : null
+  }
+  return example
+}
+
+
+function inferTypeFromValue(value: any): string {
+  if (null == value) return 'string'
+  if ('boolean' === typeof value) return 'boolean'
+  if ('number' === typeof value) {
+    return Number.isInteger(value) ? 'integer' : 'number'
+  }
+  if ('string' === typeof value) return 'string'
+  if (Array.isArray(value)) return 'array'
+  if ('object' === typeof value) return 'object'
+  return 'string'
+}
+
+
 function mergeField(
   ment: ModelEntity,
   mop: ModelOp,
@@ -179,4 +272,6 @@ function mergeField(
 
 export {
   fieldTransform,
+  inferFieldsFromExamples,
+  inferTypeFromValue,
 }

package/src/utility.ts

@@ -120,21 +120,27 @@ function depluralize(word: string): string {
     'horses': 'horse',
     'house': 'houses',
     'indices': 'index',
+    'lens': 'lens',
     'license': 'licenses',
     'matrices': 'matrix',
     'men': 'man',
     'mice': 'mouse',
+    'movies': 'movie',
     'notice': 'notices',
     'oases': 'oasis',
+    'phrase': 'phrase',
     'releases': 'release',
     'people': 'person',
     'phenomena': 'phenomenon',
     'practice': 'practices',
     'promise': 'promises',
+    'series': 'series',
+    'species': 'species',
     'teeth': 'tooth',
     'theses': 'thesis',
     'vertices': 'vertex',
     'women': 'woman',
+    'yes': 'yes',
   }
 
   if (irregulars[word]) {
@@ -149,14 +155,12 @@ function depluralize(word: string): string {
 
   // Rules for regular plurals (applied in order)
 
+  // -ies -> -y (cities -> city), but only if result is > 2 chars
   if (word.endsWith('ies') && word.length > 3) {
-    return word.slice(0, -3) + 'y'
-  }
-
-
-  // -ies -> -y (cities -> city)
-  if (word.endsWith('ies') && word.length > 3) {
-    return word.slice(0, -3) + 'y'
+    const result = word.slice(0, -3) + 'y'
+    if (result.length > 2) {
+      return result
+    }
   }
 
   // -ves -> -f or -fe (wolves -> wolf, knives -> knife)
@@ -186,10 +190,11 @@ function depluralize(word: string): string {
     return word.slice(0, -2)
   }
 
-  // -s -> remove -s (cats -> cat)
+  // -s -> remove -s (cats -> cat), but only if result is > 2 chars
   if (word.endsWith('s') &&
     !word.endsWith('ss') &&
-    !word.endsWith('us')
+    !word.endsWith('us') &&
+    word.length > 3
   ) {
     return word.slice(0, -1)
   }
@@ -726,8 +731,150 @@ function validator(torig: undefined | string | string[]): any {
   }
 }
 
+const FILE_EXT_RE =
+  /\.(php|json|txt|png|jpg|jpeg|gif|svg|xml|html|csv|yml|yaml|md)$/i
+
+function transliterate(s: string): string {
+  return s.normalize('NFD').replace(/[\u0300-\u036f]/g, '')
+}
+
 function canonize(s: string) {
-  return depluralize(snakify(s)).replace(/[^a-zA-Z_0-9]/g, '')
+  if (null == s || '' === s) return ''
+  return depluralize(snakify(transliterate(s).replace(FILE_EXT_RE, '')))
+    .replace(/[^a-zA-Z_0-9]/g, '')
+}
+
+
+// Sanitize a raw slug into a clean kebab-case string suitable for
+// conversion to a valid JS identifier (via camelify/snakify/etc).
+function sanitizeSlug(s: string): string {
+  if (null == s || '' === s) return 'unknown'
+  // Transliterate accented characters to ASCII
+  let out = transliterate(s)
+  // Replace underscores and dots with hyphens (treat as word separators)
+  out = out.replace(/[_.]/g, '-')
+  // Strip all non-alphanumeric, non-hyphen chars
+  out = out.replace(/[^a-zA-Z0-9-]/g, '')
+  // Collapse multiple/leading/trailing hyphens
+  out = out.replace(/-+/g, '-').replace(/^-|-$/g, '')
+
+  // Merge standalone number segments with preceding word
+  // e.g. ec-2-shop -> ec2-shop, advice-slip-api-2 -> advice-slip-api2
+  const raw = out.split('-').filter(p => p.length > 0)
+  const parts: string[] = []
+  for (const p of raw) {
+    if (/^\d+$/.test(p) && parts.length > 0) {
+      parts[parts.length - 1] += p
+    } else {
+      parts.push(p)
+    }
+  }
+  out = parts.join('-')
+
+  if (!out) return 'unknown'
+  return out
+}
+
+
+const BOOLEAN_NAME_RE = /^(is_|has_|can_|should_|allow_|enabled$|disabled$|active$|visible$|deleted$|verified$|public$|private$|locked$|archived$|blocked$)/
+const INTEGER_NAME_RE = /(_count$|_number$|^total_|^count_|^num_|^limit$|^page$|^offset$|^per_page$|^page_size$|^size$|^skip$)/
+const NUMBER_NAME_RE = /^(latitude$|longitude$|lat$|lng$|lon$|price$|amount$|rate$|score$|weight$|height$|width$|depth$|radius$|distance$|duration$|percentage$|percent$)/
+const STRING_NAME_RE = /^(url$|href$|link$|uri$|email$|name$|title$|description$|slug$|path$|label$|username$|password$|token$|key$)/
+const ID_NAME_RE = /(_id$|^id$)/
+
+function inferFieldType(name: string, specType: string): string {
+  // Only override $ANY, or $STRING for boolean-patterned names
+  if ('`$ANY`' === specType) {
+    if (BOOLEAN_NAME_RE.test(name)) return '`$BOOLEAN`'
+    if (ID_NAME_RE.test(name)) return '`$STRING`'
+    if (INTEGER_NAME_RE.test(name)) return '`$INTEGER`'
+    if (NUMBER_NAME_RE.test(name)) return '`$NUMBER`'
+    if (STRING_NAME_RE.test(name)) return '`$STRING`'
+  }
+  else if ('`$STRING`' === specType) {
+    if (BOOLEAN_NAME_RE.test(name)) return '`$BOOLEAN`'
+  }
+  return specType
+}
+
+
+function normalizeFieldName(s: string): string {
+  if (null == s || '' === s) return ''
+  return s
+    .replace(/\[\]/g, '')
+    .replace(/[\[\].]+/g, '_')
+    .replace(/_+/g, '_')
+    .replace(/^_|_$/g, '')
+}
+
+
+const MIN_ENTITY_NAME_LEN = 3
+const MAX_ENTITY_NAME_LEN = 67
+
+function ensureMinEntityName(
+  name: string,
+  existing: Record<string, any>,
+): string {
+  let padded = name.replace(/[^a-zA-Z_0-9]/g, '').replace(/^_+/, '')
+
+  // Truncate sentence-length names by taking leading segments
+  if (padded.length > MAX_ENTITY_NAME_LEN) {
+    const parts = padded.split('_')
+    let truncated = ''
+    for (const part of parts) {
+      const next = truncated === '' ? part : truncated + '_' + part
+      if (next.length > MAX_ENTITY_NAME_LEN) break
+      truncated = next
+    }
+    padded = truncated || parts[0].substring(0, MAX_ENTITY_NAME_LEN)
+  }
+
+  if (padded.length > 0 && padded[0] >= '0' && padded[0] <= '9') {
+    padded = 'n' + padded
+  }
+  if (padded.length < MIN_ENTITY_NAME_LEN) {
+    const padding = 'nt'.substring(0, MIN_ENTITY_NAME_LEN - padded.length)
+    padded = padded + padding
+  }
+
+  if (padded !== name && null != existing[padded]) {
+    let i = 2
+    while (null != existing[padded + i]) {
+      i++
+    }
+    padded = padded + i
+  }
+
+  return padded
+}
+
+
+const CMP_SUFFIXES = ['_rest_controller', '_controller', '_response', '_request']
+const CMP_PREFIXES = ['get_', 'post_', 'put_', 'delete_', 'patch_']
+
+function cleanComponentName(name: string): string {
+  let cleaned = name
+
+  for (const suffix of CMP_SUFFIXES) {
+    if (cleaned.endsWith(suffix)) {
+      const parts = cleaned.split('_')
+      const suffixParts = suffix.split('_').filter(s => s !== '').length
+      cleaned = canonize(parts.slice(0, parts.length - suffixParts).join('_'))
+      break
+    }
+  }
+
+  for (const prefix of CMP_PREFIXES) {
+    if (cleaned.startsWith(prefix)) {
+      const remainder = cleaned.substring(prefix.length)
+      if (remainder.length >= 3) {
+        cleaned = remainder
+      }
+      break
+    }
+  }
+
+  return cleaned
 }
 
 
@@ -942,6 +1089,12 @@ export {
   formatJSONIC,
   validator,
   canonize,
+  sanitizeSlug,
+  transliterate,
+  cleanComponentName,
+  ensureMinEntityName,
+  inferFieldType,
+  normalizeFieldName,
   debugpath,
   findPathsWithPrefix,
   writeFileSyncWarn,