@voxgig/apidef 3.0.2 → 3.1.1

package/src/transform/select.ts

@@ -1,11 +1,9 @@
 
 
-import { each, snakify } from 'jostraca'
+import { each } from 'jostraca'
 
 import type { TransformResult, Transform } from '../transform'
 
-import { formatJSONIC, depluralize, validator } from '../utility'
-
 
 import { KIT } from '../types'
 
@@ -16,8 +14,6 @@ import type {
 
 import type {
   PathDef,
-  ParameterDef,
-  MethodDef,
 } from '../def'
 
 import type {
@@ -30,7 +26,7 @@ import type {
 
 
 
-const selectTransform = async function(
+const selectTransform: Transform = async function(
   ctx: any,
 ): Promise<TransformResult> {
   const { apimodel, def, guide } = ctx
@@ -38,12 +34,15 @@ const selectTransform = async function(
 
   let msg = 'select '
 
-  each(kit.entity, (ment: ModelEntity, entname: string) => {
-    each(ment.op, (mop: ModelOp, opname: OpName) => {
+  each(kit.entity, (ment: ModelEntity, _entname: string) => {
+    each(ment.op, (mop: ModelOp, _opname: OpName) => {
       each(mop.alts, (malt: ModelAlt) => {
         const pdef: PathDef = def.paths[malt.orig]
         resolveSelect(guide, ment, mop, malt, pdef)
       })
+      if (null != mop.alts && 0 < mop.alts.length) {
+        sortAlts(guide, ment, mop)
+      }
     })
 
     msg += ment.name + ' '
@@ -53,7 +52,13 @@ const selectTransform = async function(
 }
 
 
-function resolveSelect(guide: Guide, ment: ModelEntity, mop: ModelOp, malt: ModelAlt, pdef: PathDef) {
+function resolveSelect(
+  guide: Guide,
+  ment: ModelEntity,
+  _mop: ModelOp,
+  malt: ModelAlt,
+  _pdef: PathDef
+) {
   const select: any = malt.select
   const margs: any = malt.args
 
@@ -61,19 +66,17 @@ function resolveSelect(guide: Guide, ment: ModelEntity, mop: ModelOp, malt: Mode
 
   argkinds.map((kind: string) => {
     each(margs[kind], (marg: ModelArg) => {
-      select[kind] = (select[kind] ?? {})
-
-      if (marg.req) {
-        select[kind][marg.name] = true
+      if (!select.exist.includes(marg.name)) {
+        select.exist.push(marg.name)
       }
     })
   })
 
+  select.exist.sort()
+
   const gent = guide.entity[ment.name]
   const gpath = gent.path[malt.orig]
 
-  // console.log('GPATH', gpath)
-
   if (gpath.action) {
     const actname = Object.keys(gpath.action)[0]
 
@@ -85,6 +88,32 @@ function resolveSelect(guide: Guide, ment: ModelEntity, mop: ModelOp, malt: Mode
 }
 
 
+function sortAlts(
+  _guide: Guide,
+  _ment: ModelEntity,
+  mop: ModelOp,
+) {
+  mop.alts.sort((a: ModelAlt, b: ModelAlt) => {
+    // longest exist len first
+    let order = b.select.exist.length - a.select.exist.length
+    if (0 === order) {
+      if (null != a.select.$action && null != b.select.$action) {
+        order = a.select.$action < b.select.$action ? -1 :
+          a.select.$action > b.select.$action ? 1 : 0
+      }
+
+      if (0 === order) {
+        const a_exist_str = a.select.exist.join('\t')
+        const b_exist_str = b.select.exist.join('\t')
+        order = a_exist_str < b_exist_str ? -1 :
+          a_exist_str > b_exist_str ? 1 : 0
+      }
+    }
+
+    return order
+  })
+}
+
 export {
   selectTransform,
 }

package/src/transform/top.ts

@@ -1,6 +1,4 @@
 
-import { each, getx } from 'jostraca'
-
 import { joinurl } from '@voxgig/struct'
 
 import { KIT } from '../types'
@@ -9,37 +7,16 @@ import type { TransformResult } from '../transform'
 
 import type {
   KitModel,
-  TypeName,
-  MethodName,
 } from '../types'
 
 import type {
-  PathDef,
-  MethodDef,
-  ServerDef,
-  ServerVariableDef,
-  ParameterDef,
-  SchemaDef,
-} from '../def'
-
-import type {
-  GuidePathRename,
-  GuideOp,
-  GuidePath,
+  // GuidePath,
   PathDesc,
   OpDesc,
 } from '../desc'
 
 import type {
   OpName,
-  ModelEntityRelations,
-  ModelOpMap,
-  ModelFieldOp,
-  ModelField,
-  ModelArg,
-  ModelAlt,
-  ModelOp,
-  ModelEntity,
 } from '../model'
 
 
@@ -49,22 +26,13 @@ import type {
 // Model* => Generated SDK Model
 
 
-type GuideEntity = {
-  name: string,
-  path: Record<string, GuidePath>
-
-  paths$: PathDesc[]
-  opm$: Record<OpName, OpDesc>
-}
-
-
-
-
-
-
-
-
+// type GuideEntity = {
+//   name: string,
+//   path: Record<string, GuidePath>
 
+//   paths$: PathDesc[]
+//   opm$: Record<OpName, OpDesc>
+// }
 
 
 const topTransform = async function(
@@ -91,6 +59,7 @@ export {
   topTransform
 }
 
-export type {
-  GuideEntity,
-}
+
+// export type {
+//   GuideEntity,
+// }

package/src/transform.ts

@@ -39,10 +39,10 @@ type TransformResult = {
 
 type Transform = (
   ctx: TransformCtx,
-  guide: Guide,
-  tspec: TransformSpec,
-  apimodel: any,
-  def: any,
+  // guide: Guide,
+  // tspec: TransformSpec,
+  // apimodel: any,
+  // def: any,
 ) => Promise<TransformResult>
 
 type ProcessResult = {

package/src/types.ts

@@ -96,17 +96,13 @@ type Build = ReturnType<typeof BuildShape>
 
 
 type ApiModel = {
-  /*
   main: {
-    api: Record<string, any>
-    sdk: {
+    kit: {
       info: Record<string, any>
       entity: Record<string, any>
       flow: Record<string, any>
     }
-    def: Record<string, any>
-    }
-    */
+  }
 }
 
 

package/src/utility.ts

@@ -39,7 +39,7 @@ function writeFileSyncWarn(warn: Warner, fs: any, path: string, text: string) {
   catch (err: any) {
     warn({
       err,
-      note: 'Unable to save file: ' + path
+      note: 'Unable to save file: ' + relativizePath(path)
     })
   }
 }
@@ -780,6 +780,8 @@ function allcapify(s?: string) {
 }
 
 
+// Get value from object as string, and format as indicated.
+// Example: nom({foo:'bar'},'Foo') -> 'Bar'
 function nom(v: any, format: string): string {
   let formatstr = 'string' == typeof format ? format : null
   if (null == formatstr) {
@@ -795,6 +797,88 @@ function nom(v: any, format: string): string {
   return out
 }
 
+
+function relativizePath(path: string): string {
+  const cwd = process.cwd()
+  if (path.startsWith(cwd)) {
+    return '.' + path.slice(cwd.length)
+  }
+  return path
+}
+
+
+function getModelPath(
+  model: any,
+  path: string,
+  flags?: { required?: boolean }
+): any {
+  const required = flags?.required ?? true
+
+  if (path === '') {
+    if (required) {
+      throw new Error('getModelPath: empty path provided')
+    }
+    return undefined
+  }
+
+  const parts = path.split('.')
+  const fullPath = path  // Store the full path for error messages
+  let current = model
+  let validPath: string[] = []
+
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i]
+
+    if (current == null) {
+      if (required) {
+        const validPathStr = validPath.length > 0 ? validPath.join('.') : '(root)'
+        throw new Error(
+          `getModelPath: path not found at '${fullPath}'.\n` +
+          `Valid path up to: '${validPathStr}'.\n` +
+          `Cannot access property '${part}' of ${current === null ? 'null' : 'undefined'}.`
+        )
+      }
+      return undefined
+    }
+
+    // Check if current is an object before using 'in' operator
+    if (typeof current !== 'object' || current === null) {
+      if (required) {
+        const validPathStr = validPath.length > 0 ? validPath.join('.') : '(root)'
+        throw new Error(
+          `getModelPath: path not found at '${fullPath}'.\n` +
+          `Valid path up to: '${validPathStr}'.\n` +
+          `Cannot access property '${part}' of ${typeof current}.`
+        )
+      }
+      return undefined
+    }
+
+    // Check if the key exists
+    if (!(part in current)) {
+      if (required) {
+        const validPathStr = validPath.length > 0 ? validPath.join('.') : '(root)'
+        const availableKeys = Array.isArray(current)
+          ? `array indices 0-${current.length - 1}`
+          : `[${Object.keys(current).join(', ')}]`
+
+        throw new Error(
+          `getModelPath: path not found at '${fullPath}'.\n` +
+          `Valid path up to: '${validPathStr}'.\n` +
+          `Property '${part}' does not exist.\n` +
+          `Available keys: ${availableKeys}`
+        )
+      }
+      return undefined
+    }
+
+    validPath.push(part)
+    current = current[part]
+  }
+
+  return current
+}
+
 export type {
   PathMatch
 }
@@ -816,5 +900,7 @@ export {
   findPathsWithPrefix,
   writeFileSyncWarn,
   warnOnError,
+  relativizePath,
+  getModelPath,
 
 }