@voxgig/sdkgen 0.25.0 → 0.28.0

package/project/.sdk/model/feature/log.jsonic

@@ -1,7 +1,7 @@
 
-main: sdk: feature: log: {
+main: kit: feature: log: {
 
-  name: .$KEY
+  name: key()
   title: Log
   version: '0.0.1'
   active: true
@@ -15,7 +15,7 @@ main: sdk: feature: log: {
     SetMatch: active: true
     GetMatch: active: true
 
-    PreOperation: active: true
+    PreTarget: active: true
     PreSpec: active: true
     PreRequest: active: true
     PreResponse: active: true

package/project/.sdk/model/feature/test.jsonic

@@ -1,11 +1,16 @@
 
-main: sdk: feature: test: {
+main: kit: feature: test: {
 
-  name: .$KEY
+  name: key()
   title: Test
   version: '0.0.1'
   active: true
 
+  config: {
+    # Test mode is not active by default, unlike most features
+    options: active: false
+  }
+  
   hook: {
     PostConstruct: active: true
     PostConstructEntity: active: true
@@ -14,7 +19,7 @@ main: sdk: feature: test: {
     SetMatch: active: true
     GetMatch: active: true
 
-    PreOperation: active: true
+    PreTarget: active: true
     PreSpec: active: true
     PreRequest: active: true
     PreResponse: active: true

package/project/.sdk/model/target/go.jsonic

@@ -1,7 +1,22 @@
 
-title: Golang
-ext: go
-comment: line: "//"
-module: name: $$name$$
+main: kit: target: go: {
 
+  title: Golang
+  ext: go
+  comment: line: "//"
+  module: name: $$name$$
+  srcfeature: false
 
+  deps: &: {
+    kind: *'prod' | string
+  }
+
+  deps: {
+    'github.com/voxgig/struct': { active: true, version: 'v0.0.0', replace: './utility/struct' }
+  }
+}
+
+
+main: kit: feature: &: target: go: deps: &: {
+  kind: *'prod' | string
+}

package/project/.sdk/model/target/js.jsonic

@@ -1,5 +1,5 @@
 
-main: sdk: target: js: {
+main: kit: target: js: {
   
   title: JavaScript
   ext: js
@@ -17,7 +17,7 @@ main: sdk: target: js: {
 }
 
 
-main: sdk: feature: &: target: js: deps: &: {
+main: kit: feature: &: target: js: deps: &: {
   # TODO: fix aontu disjunctions!
   kind: *'prod' | string # 'peer' |'dev'
 }

package/project/.sdk/model/target/ts.jsonic

@@ -1,5 +1,5 @@
 
-main: sdk: target: ts: {
+main: kit: target: ts: {
   
   title: TypeScript
   ext: ts
@@ -13,14 +13,14 @@ main: sdk: target: ts: {
   }
   
   deps: {
-    'dotenv': { active: true, version: '^16.4.5', kind: dev }
-    'typescript': { active: true, version: '^5.8.3', kind: dev }
-    '@types/node': { active: true, version: '^22.15.3', kind: dev }
+    'dotenv': { active: true, version: '^17.3.1', kind: dev }
+    'typescript': { active: true, version: '^5.9.3', kind: dev }
+    '@types/node': { active: true, version: '^25.3.3', kind: dev }
   }
 }
 
 
-main: sdk: feature: &: target: ts: deps: &: {
+main: kit: feature: &: target: ts: deps: &: {
   # TODO: fix aontu disjunctions!
   kind: *'prod' | string # 'peer' |'dev'
 }

package/project/.sdk/src/cmp/go/Config_go.ts

@@ -0,0 +1,119 @@
+
+import * as Path from 'node:path'
+
+
+import {
+  Content,
+  File,
+  Fragment,
+  Line,
+  cmp,
+  each,
+} from '@voxgig/sdkgen'
+
+
+import {
+  KIT,
+  Model,
+  getModelPath,
+  nom,
+} from '@voxgig/apidef'
+
+
+import {
+  clean,
+  formatGoMap,
+} from './utility_go'
+
+
+const Config = cmp(async function Config(props: any) {
+  const ctx$ = props.ctx$
+  const target = props.target
+
+  const model: Model = ctx$.model
+
+  const entity = getModelPath(model, `main.${KIT}.entity`)
+  const feature = getModelPath(model, `main.${KIT}.feature`)
+
+  const headers = getModelPath(model, `main.${KIT}.config.headers`) || {}
+  const authPrefix = getModelPath(model, `main.${KIT}.config.auth.prefix`)
+  const baseUrl = getModelPath(model, `main.${KIT}.info.servers.0.url`)
+
+  // Config is now in core/ package
+  File({ name: 'config.' + target.ext }, () => {
+
+    Content(`package core
+
+`)
+
+    Content(`func MakeConfig() map[string]any {
+	return map[string]any{
+		"main": map[string]any{
+			"name": "${model.const.Name}",
+		},
+		"feature": map[string]any{
+`)
+
+    each(feature, (f: any) => {
+      const fconfig = f.config || {}
+      Content(`			"${f.name}": ${formatGoMap(fconfig, 3)},
+`)
+    })
+
+    Content(`		},
+		"options": map[string]any{
+			"base": "${baseUrl}",
+			"auth": map[string]any{
+				"prefix": "${authPrefix}",
+			},
+			"headers": ${formatGoMap(headers, 3)},
+			"entity": map[string]any{
+`)
+
+    each(entity, (entity: any) => {
+      Content(`				"${entity.name}": map[string]any{},
+`)
+    })
+
+    Content(`			},
+		},
+		"entity": ${formatGoMap(
+      Object.values(entity).reduce((a: any, n: any) => (a[n.name] = clean({
+        fields: n.fields,
+        name: n.name,
+        op: n.op,
+        relations: n.relations,
+      }), a), {}), 2)},
+	}
+}
+
+func makeFeature(name string) Feature {
+	switch name {
+`)
+
+    each(feature, (f: any) => {
+      const fname = f.name.charAt(0).toUpperCase() + f.name.slice(1)
+      if (f.name !== 'base') {
+        Content(`	case "${f.name}":
+		if New${fname}FeatureFunc != nil {
+			return New${fname}FeatureFunc()
+		}
+`)
+      }
+    })
+
+    Content(`	default:
+		if NewBaseFeatureFunc != nil {
+			return NewBaseFeatureFunc()
+		}
+	}
+	return nil
+}
+`)
+  })
+})
+
+
+export {
+  Config
+}

package/project/.sdk/src/cmp/go/EntityOperation_go.ts

@@ -0,0 +1,48 @@
+
+import {
+  cmp, camelify,
+  Content, Fragment
+} from '@voxgig/sdkgen'
+
+
+import { formatGoMap } from './utility_go'
+
+
+const EntityOperation = cmp(function Operation(props: any) {
+  const { model } = props.ctx$
+  const { ff, opname, entity, entrep, gomodule } = props
+
+  let { indent } = props
+
+  if (null != indent) {
+    indent = indent.substring(1)
+    if ('' == indent) {
+      indent = undefined
+    }
+  }
+
+  const entop = entity.op[opname]
+
+  Fragment({
+    from: ff + '/Entity' + camelify(opname) + 'Op.fragment.go',
+    eject: ['// EJECT-START', '// EJECT-END'],
+    indent,
+    replace: {
+      ...entrep,
+      'GOMODULE': gomodule,
+      ProjectName: model.const.Name,
+      EntityName: entity.Name,
+      entityname: entity.name,
+      '#Feature-Hook': ({ name, indent }: any) =>
+        Content({ indent }, `
+u.FeatureHook(ctx, "${name}")
+`)
+
+    }
+  })
+})
+
+
+export {
+  EntityOperation
+}

package/project/.sdk/src/cmp/go/Entity_go.ts

@@ -0,0 +1,67 @@
+
+import * as Path from 'node:path'
+
+import {
+  cmp, each, camelify, names,
+  File, Content, Folder, Fragment, Line, FeatureHook, Slot
+} from '@voxgig/sdkgen'
+
+import { EntityOperation } from './EntityOperation_go'
+
+
+const Entity = cmp(function Entity(props: any) {
+  const { model, stdrep } = props.ctx$
+  const { target, entity } = props
+
+  // Module name: concatenated lowercase
+  const orgPrefix = (model.origin || '').replace(/-sdk$/, '').replace(/[^a-z0-9]/gi, '')
+  const gomodule = orgPrefix + model.name + 'sdk'
+
+  const entrep = {
+    ...stdrep,
+  }
+
+  names(entrep, entity.Name, 'EntityName')
+
+  const ff = Path.normalize(__dirname + '/../../../src/cmp/go/fragment/')
+
+  // Entity files go to entity/ folder with snake_case names
+  Folder({ name: 'entity' }, () => {
+
+    File({ name: entity.name + '_entity.' + target.ext }, () => {
+
+      const opnames = Object.keys(entity.op)
+
+      const opfrags =
+        (['load', 'list', 'create', 'update', 'remove']
+          .reduce((a: any, opname: string) =>
+          (a['// #' + camelify(opname) + 'Op'] =
+            !opnames.includes(opname) ? '' : ({ indent }: any) => {
+              EntityOperation({ ff, opname, indent, entity, entrep, gomodule })
+            }, a), {}))
+
+      Fragment({
+        from: ff + 'Entity.fragment.go',
+        replace: {
+          ...entrep,
+          'GOMODULE': gomodule,
+          ProjectName: model.const.Name,
+          EntityName: entity.Name,
+          entityname: entity.name,
+
+          '#Entity-Hook': ({ name, indent }: any) =>
+            Content({ indent }, `utility.FeatureHook(ctx, "${name}")`),
+
+          ...opfrags,
+        }
+      })
+
+    })
+  })
+})
+
+
+
+export {
+  Entity
+}

package/project/.sdk/src/cmp/go/MainEntity_go.ts

@@ -0,0 +1,22 @@
+
+
+import { cmp, Content } from '@voxgig/sdkgen'
+
+
+const MainEntity = cmp(async function MainEntity(props: any) {
+  const { entity, gomodule } = props
+  const { model } = props.ctx$
+
+  Content(`
+func (sdk *${model.const.Name}SDK) ${entity.Name}(data map[string]any) ${model.const.Name}Entity {
+	return New${entity.Name}EntityFunc(sdk, data)
+}
+
+`)
+
+})
+
+
+export {
+  MainEntity
+}

package/project/.sdk/src/cmp/go/Main_go.ts

@@ -0,0 +1,209 @@
+
+import * as Path from 'node:path'
+
+import {
+  cmp, each, names, cmap,
+  List, File, Content, Copy, Folder, Fragment, Line, FeatureHook,
+} from '@voxgig/sdkgen'
+
+
+import type {
+  ModelEntity
+} from '@voxgig/apidef'
+
+
+import {
+  KIT,
+  getModelPath
+} from '@voxgig/apidef'
+
+
+import { Package } from './Package_go'
+import { Config } from './Config_go'
+import { MainEntity } from './MainEntity_go'
+
+
+const Main = cmp(async function Main(props: any) {
+
+  const { target } = props
+  const { model } = props.ctx$
+
+  const entity: ModelEntity = getModelPath(model, `main.${KIT}.entity`)
+  const feature = getModelPath(model, `main.${KIT}.feature`)
+
+  // Module name: concatenated lowercase (e.g., voxgigsolardemosdk)
+  const orgPrefix = (model.origin || '').replace(/-sdk$/, '').replace(/[^a-z0-9]/gi, '')
+  const gomodule = orgPrefix + model.name + 'sdk'
+
+  Package({ target })
+
+  // Copy tm/go files with replacements
+  Copy({
+    from: 'tm/' + target.name,
+    exclude: [/src\//],
+    replace: {
+      ...props.ctx$.stdrep,
+      GOMODULE: gomodule,
+    }
+  })
+
+  // Generate main SDK file in core/ folder
+  Folder({ name: 'core' }, () => {
+
+    File({ name: model.name + '_sdk.' + target.ext }, () => {
+
+      Fragment(
+        {
+          from: Path.normalize(__dirname + '/../../../src/cmp/go/fragment/Main.fragment.go'),
+          replace: {
+            ...props.ctx$.stdrep,
+            'ProjectNameModule': gomodule,
+
+            '#BuildFeatures': ({ indent }: any) => {
+              each(feature, (feat: any) => {
+                if (feat.name === 'base') {
+                  Content({ indent }, `u.FeatureAdd(s.rootctx, NewBaseFeatureFunc())
+`)
+                } else if (feat.name === 'test') {
+                  Content({ indent }, `u.FeatureAdd(s.rootctx, NewTestFeatureFunc())
+`)
+                }
+              })
+            },
+
+            '#Feature-Hook': ({ name, indent }: any) => Content({ indent }, `
+s.utility.FeatureHook(s.rootctx, "${name}")
+`),
+
+          }
+        },
+
+        // Entities - injected at SLOT
+        () => {
+          each(entity, (entity: ModelEntity) => {
+            const entitySDK = getModelPath(model, `main.${KIT}.entity.${entity.name}`)
+            const entprops = { target, entity, entitySDK, gomodule }
+            MainEntity(entprops)
+          })
+        })
+    })
+
+    Config({ target })
+
+    // Generate registry.go with all constructor function vars
+    File({ name: 'registry.' + target.ext }, () => {
+      Content(`package core
+
+var UtilityRegistrar func(u *Utility)
+
+var NewBaseFeatureFunc func() Feature
+
+`)
+      // Feature constructor function vars (non-base)
+      each(feature, (feat: any) => {
+        if (feat.name !== 'base') {
+          const fname = feat.name.charAt(0).toUpperCase() + feat.name.slice(1)
+          Content(`var New${fname}FeatureFunc func() Feature
+
+`)
+        }
+      })
+
+      // Entity constructor function vars
+      each(entity, (ent: any) => {
+        Content(`var New${ent.Name}EntityFunc func(client *${model.const.Name}SDK, entopts map[string]any) ${model.const.Name}Entity
+
+`)
+      })
+    })
+  })
+
+  // Generate root package file
+  File({ name: model.name + '.' + target.ext }, () => {
+    Content(`package ${gomodule}
+
+import (
+	"${gomodule}/core"
+	"${gomodule}/entity"
+	"${gomodule}/feature"
+	_ "${gomodule}/utility"
+)
+
+// Type aliases preserve external API.
+type ${model.const.Name}SDK = core.${model.const.Name}SDK
+type Context = core.Context
+type Utility = core.Utility
+type Feature = core.Feature
+type Entity = core.Entity
+type ${model.const.Name}Entity = core.${model.const.Name}Entity
+type FetcherFunc = core.FetcherFunc
+type Spec = core.Spec
+type Result = core.Result
+type Response = core.Response
+type Operation = core.Operation
+type Control = core.Control
+type ${model.const.Name}Error = core.${model.const.Name}Error
+
+// BaseFeature from feature package.
+type BaseFeature = feature.BaseFeature
+
+func init() {
+`)
+
+    // Register feature constructors - base is always present
+    Content(`	core.NewBaseFeatureFunc = func() core.Feature {
+		return feature.NewBaseFeature()
+	}
+`)
+
+    // Register non-base feature constructors
+    each(feature, (feat: any) => {
+      if (feat.name !== 'base') {
+        const fname = feat.name.charAt(0).toUpperCase() + feat.name.slice(1)
+        Content(`	core.New${fname}FeatureFunc = func() core.Feature {
+		return feature.New${fname}Feature()
+	}
+`)
+      }
+    })
+
+    // Register entity constructors
+    each(entity, (ent: any) => {
+      Content(`	core.New${ent.Name}EntityFunc = func(client *core.${model.const.Name}SDK, entopts map[string]any) core.${model.const.Name}Entity {
+		return entity.New${ent.Name}Entity(client, entopts)
+	}
+`)
+    })
+
+    Content(`}
+
+// Constructor re-exports.
+var New${model.const.Name}SDK = core.New${model.const.Name}SDK
+var TestSDK = core.TestSDK
+var NewContext = core.NewContext
+var NewSpec = core.NewSpec
+var NewResult = core.NewResult
+var NewResponse = core.NewResponse
+var NewOperation = core.NewOperation
+var MakeConfig = core.MakeConfig
+`)
+
+    // Feature constructor re-exports - base is always present
+    Content(`var NewBaseFeature = feature.NewBaseFeature
+`)
+
+    each(feature, (feat: any) => {
+      if (feat.name !== 'base') {
+        const fname = feat.name.charAt(0).toUpperCase() + feat.name.slice(1)
+        Content(`var New${fname}Feature = feature.New${fname}Feature
+`)
+      }
+    })
+  })
+
+})
+
+
+export {
+  Main
+}

package/project/.sdk/src/cmp/go/Package_go.ts

@@ -0,0 +1,89 @@
+
+import {
+  Content,
+  File,
+  cmp,
+  each,
+} from '@voxgig/sdkgen'
+
+
+import {
+  KIT,
+  Model,
+  getModelPath,
+} from '@voxgig/apidef'
+
+
+const Package = cmp(async function Package(props: any) {
+  const ctx$ = props.ctx$
+  const target = props.target
+
+  const model: Model = ctx$.model
+
+  const feature = getModelPath(model, `main.${KIT}.feature`)
+
+  // Module name: concatenated lowercase (e.g., voxgigsolardemosdk)
+  const orgPrefix = (model.origin || '').replace(/-sdk$/, '').replace(/[^a-z0-9]/gi, '')
+  const gomodule = orgPrefix + model.name + 'sdk'
+
+  File({ name: 'go.mod' }, () => {
+    Content(`module ${gomodule}
+
+go 1.20
+
+`)
+
+    // Collect dependencies from features
+    const deps: Record<string, string> = {}
+    const replaceDirs: Record<string, string> = {}
+
+    each(feature, (f: any) => {
+      const goDeps = f.deps?.go
+      if (goDeps) {
+        each(goDeps, (dep: any) => {
+          if (dep.active) {
+            deps[dep.key$] = dep.version
+          }
+        })
+      }
+    })
+
+    // Add target-level deps
+    const targetDeps = target.deps
+    if (targetDeps) {
+      each(targetDeps, (dep: any) => {
+        if (dep.active !== false) {
+          deps[dep.key$] = dep.version || 'v0.0.0'
+          if (dep.replace) {
+            replaceDirs[dep.key$] = dep.replace
+          }
+        }
+      })
+    }
+
+    if (Object.keys(deps).length > 0) {
+      Content(`require (
+`)
+      for (const [name, version] of Object.entries(deps)) {
+        Content(`\t${name} ${version}
+`)
+      }
+      Content(`)
+`)
+    }
+
+    if (Object.keys(replaceDirs).length > 0) {
+      Content(`
+`)
+      for (const [name, dir] of Object.entries(replaceDirs)) {
+        Content(`replace ${name} => ${dir}
+`)
+      }
+    }
+  })
+})
+
+
+export {
+  Package
+}