@voxgig/apidef 1.9.0 → 2.0.2

package/src/transform.ts

@@ -11,7 +11,7 @@ import { topTransform } from './transform/top'
 import { entityTransform } from './transform/entity'
 import { operationTransform } from './transform/operation'
 import { fieldTransform } from './transform/field'
-import { manualTransform } from './transform/manual'
+// import { manualTransform } from './transform/manual'
 
 
 
@@ -55,7 +55,7 @@ const TRANSFORM: Record<string, Transform> = {
   entity: entityTransform,
   operation: operationTransform,
   field: fieldTransform,
-  manual: manualTransform,
+  // manual: manualTransform,
 }
 
 
@@ -98,10 +98,15 @@ async function resolveTransforms(ctx: TransformCtx): Promise<TransformSpec> {
     order: transformNames
   })
 
-  for (const tn of transformNames) {
-    log.debug({ what: 'transform', transform: tn, note: tn })
-    const transform = await resolveTransform(tn, ctx)
-    tspec.transform.push(transform)
+  try {
+    for (const tn of transformNames) {
+      log.debug({ what: 'transform', transform: tn, note: tn })
+      const transform = await resolveTransform(tn, ctx)
+      tspec.transform.push(transform)
+    }
+  }
+  catch (err: any) {
+    throw err
   }
 
   return tspec
@@ -146,10 +151,10 @@ async function resolveTransform(tn: string, ctx: TransformCtx) {
 }
 
 
-
 async function processTransforms(
   ctx: TransformCtx,
-  spec: TransformSpec,
+  // spec: TransformSpec,
+  transforms: any[],
   apimodel: any,
   def: any
 ): Promise<ProcessResult> {
@@ -162,15 +167,21 @@ async function processTransforms(
   const guide: Guide = GuideShape(ctx.model.main.api.guide)
 
 
-  for (let tI = 0; tI < spec.transform.length; tI++) {
-    const transform = spec.transform[tI]
+  // for (let tI = 0; tI < spec.transform.length; tI++) {
+  //  const transform = spec.transform[tI]
+
+  for (let tI = 0; tI < transforms.length; tI++) {
+    const transform = transforms[tI]
 
     try {
-      const tres = await transform(ctx, guide, spec, apimodel, def)
+      const tres = await transform(ctx, guide, apimodel, def)
       pres.ok = pres.ok && tres.ok
       pres.results.push(tres)
     }
     catch (err: any) {
+      // TODO: fix: this error does not get printed
+      console.error(err)
+
       pres.ok = false
       pres.msg += transform.name + ': ' + err.message + '\n'
       pres.results.push({

package/src/types.ts

@@ -0,0 +1,89 @@
+/* Copyright (c) 2025 Voxgig, MIT License */
+
+import * as Fs from 'node:fs'
+
+import { Pino, prettyPino } from '@voxgig/util'
+import { Gubu, Open, Any } from 'gubu'
+
+
+type FsUtil = typeof Fs
+type Log = ReturnType<typeof prettyPino>
+
+
+type ApiDefOptions = {
+  def?: string
+  fs?: any
+  pino?: ReturnType<typeof Pino>
+  debug?: boolean | string
+  folder?: string
+  meta?: Record<string, any>
+  outprefix?: string
+  strategy?: string
+}
+
+
+const ModelShape = Gubu({
+  name: String,
+  def: String,
+  main: {
+    sdk: {},
+    def: {},
+    api: {
+      guide: {},
+      entity: {},
+    },
+  }
+})
+const OpenModelShape = Gubu(Open(ModelShape), { name: 'Model' })
+
+type Model = ReturnType<typeof ModelShape>
+
+
+const BuildShape = Gubu({
+  spec: {
+    base: '',
+    path: '',
+    debug: '',
+    use: {},
+    res: [],
+    require: '',
+    log: {},
+    fs: Any(),
+    watch: {
+      mod: true,
+      add: true,
+      rem: true,
+    }
+  }
+})
+const OpenBuildShape = Gubu(Open(BuildShape))
+
+type Build = ReturnType<typeof BuildShape>
+
+
+
+type ApiModel = {
+  main: {
+    api: {
+      entity: Record<string, any>
+    }
+    def: Record<string, any>
+  }
+}
+
+
+export {
+  OpenModelShape,
+  OpenBuildShape,
+}
+
+
+export type {
+  Log,
+  FsUtil,
+  ApiDefOptions,
+  Model,
+  Build,
+  ApiModel,
+}
+

package/src/utility.ts

@@ -0,0 +1,161 @@
+
+import Path from 'node:path'
+
+
+import type {
+  FsUtil,
+  Log
+} from './types'
+
+
+function loadFile(path: string, what: string, fs: FsUtil, log: Log) {
+  try {
+    const source = fs.readFileSync(path, 'utf8')
+    return source
+  }
+  catch (err: any) {
+    log.error({ load: 'fail', what, path, err })
+    throw err
+  }
+}
+
+
+function formatJsonSrc(jsonsrc: string) {
+  return jsonsrc
+    .replace(/"([a-zA-Z_][a-zA-Z_0-9]*)": /g, '$1: ')
+    .replace(/},/g, '}\n')
+    // .replace(/([a-zA-Z_][a-zA-Z_0-9]*)_COMMENT:/g, '# $1')
+    .replace(/\n(\s*)([a-zA-Z_][a-zA-Z_0-9]*)_COMMENT:\s*"(.*)",/g, '\n\n$1# $2 $3')
+}
+
+
+function depluralize(word: string): string {
+  if (!word || word.length === 0) {
+    return word
+  }
+
+  // Common irregular plurals
+  const irregulars: Record<string, string> = {
+    'children': 'child',
+    'men': 'man',
+    'women': 'woman',
+    'teeth': 'tooth',
+    'feet': 'foot',
+    'geese': 'goose',
+    'mice': 'mouse',
+    'people': 'person',
+    'data': 'datum',
+    'criteria': 'criterion',
+    'phenomena': 'phenomenon',
+    'indices': 'index',
+    'matrices': 'matrix',
+    'vertices': 'vertex',
+    'analyses': 'analysis',
+    'axes': 'axis',
+    'crises': 'crisis',
+    'diagnoses': 'diagnosis',
+    'oases': 'oasis',
+    'theses': 'thesis',
+    'appendices': 'appendix'
+  }
+
+  if (irregulars[word]) {
+    return irregulars[word]
+  }
+
+  // Rules for regular plurals (applied in order)
+
+  // -ies -> -y (cities -> city)
+  if (word.endsWith('ies') && word.length > 3) {
+    return word.slice(0, -3) + 'y'
+  }
+
+  // -ves -> -f or -fe (wolves -> wolf, knives -> knife)
+  if (word.endsWith('ves')) {
+    const stem = word.slice(0, -3)
+    // Check if it should be -fe (like knife, wife, life)
+    if (['kni', 'wi', 'li'].includes(stem)) {
+      return stem + 'fe'
+    }
+    return stem + 'f'
+  }
+
+  // -oes -> -o (potatoes -> potato)
+  if (word.endsWith('oes')) {
+    return word.slice(0, -2)
+  }
+
+  // -ses, -xes, -zes, -shes, -ches -> remove -es (boxes -> box)
+  if (word.endsWith('ses') || word.endsWith('xes') || word.endsWith('zes') ||
+    word.endsWith('shes') || word.endsWith('ches')) {
+    return word.slice(0, -2)
+  }
+
+  // -s -> remove -s (cats -> cat)
+  if (word.endsWith('s') && !word.endsWith('ss')) {
+    return word.slice(0, -1)
+  }
+
+  // If none of the rules apply, return as is
+  return word
+}
+
+
+/*
+function writeChanged(
+  point: string, path: string, content: string,
+  fs: FsUtil, log: Log,
+  flags?: { update?: boolean }
+) {
+  let exists = false
+  let changed = false
+
+  flags = flags || {}
+  flags.update = null == flags.update ? true : !!flags.update
+
+  let action = ''
+  try {
+    let existingContent: string = ''
+    path = Path.normalize(path)
+
+    exists = fs.existsSync(path)
+
+    if (exists) {
+      action = 'read'
+      existingContent = fs.readFileSync(path, 'utf8')
+    }
+
+    changed = existingContent !== content
+
+    action = flags.update ? 'write' : 'skip'
+
+    log.info({
+      point: 'write-' + point,
+      note: (changed ? '' : 'not-') + 'changed ' + path,
+      write: 'file', skip: !changed, exists, changed,
+      contentLength: content.length, file: path
+    })
+
+    if (!exists || (changed && flags.update)) {
+      fs.writeFileSync(path, content)
+    }
+  }
+  catch (err: any) {
+    log.error({
+      fail: action, point, file: path, exists, changed,
+      contentLength: content.length, err
+    })
+    err.__logged__ = true
+    throw err
+  }
+}
+*/
+
+
+export {
+  loadFile,
+  formatJsonSrc,
+  depluralize,
+
+  // writeChanged,
+}

package/dist/transform/manual.d.ts

@@ -1,3 +0,0 @@
-import type { TransformCtx, TransformSpec, TransformResult, Guide } from '../transform';
-declare const manualTransform: (ctx: TransformCtx, guide: Guide, tspec: TransformSpec, model: any, def: any) => Promise<TransformResult>;
-export { manualTransform };

package/dist/transform/manual.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.manualTransform = void 0;
-const jsonic_1 = require("jsonic");
-const { deep } = jsonic_1.Jsonic.util;
-const manualTransform = async function (ctx, guide, tspec, model, def) {
-    const { manual } = guide;
-    deep(model, manual);
-    return { ok: true, msg: 'manual' };
-};
-exports.manualTransform = manualTransform;
-//# sourceMappingURL=manual.js.map

package/dist/transform/manual.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"manual.js","sourceRoot":"","sources":["../../src/transform/manual.ts"],"names":[],"mappings":";;;AACA,mCAA+B;AAO/B,MAAM,EAAE,IAAI,EAAE,GAAG,eAAM,CAAC,IAAI,CAAA;AAE5B,MAAM,eAAe,GAAG,KAAK,WAC3B,GAAiB,EACjB,KAAY,EACZ,KAAoB,EACpB,KAAU,EACV,GAAQ;IAGR,MAAM,EAAE,MAAM,EAAE,GAAG,KAAK,CAAA;IAExB,IAAI,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;IAEnB,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAA;AACpC,CAAC,CAAA;AAIC,0CAAe"}

package/src/transform/manual.ts

@@ -1,29 +0,0 @@
-
-import { Jsonic } from 'jsonic'
-
-import { each, getx } from 'jostraca'
-
-import type { TransformCtx, TransformSpec, TransformResult, Transform, Guide } from '../transform'
-
-
-const { deep } = Jsonic.util
-
-const manualTransform = async function(
-  ctx: TransformCtx,
-  guide: Guide,
-  tspec: TransformSpec,
-  model: any,
-  def: any
-): Promise<TransformResult> {
-
-  const { manual } = guide
-
-  deep(model, manual)
-
-  return { ok: true, msg: 'manual' }
-}
-
-
-export {
-  manualTransform
-}