@voxgig/create-sdkgen 0.0.5 → 0.0.7

package/src/create-sdkgen.ts

@@ -1,26 +1,28 @@
 /* Copyright (c) 2024 Richard Rodger, MIT License */
 
 import * as Fs from 'node:fs'
+import Path from 'node:path'
 
-import { FSWatcher } from 'chokidar'
+import { prettyPino, Pino } from '@voxgig/util'
 
 import * as JostracaModule from 'jostraca'
 
 
 
 type FullCreateSdkGenOptions = {
-  folder: string
-  fs: any
-  model: any
-  meta: any
-  rootpath: string
+  fs?: any
+  debug?: boolean | string
+  pino?: ReturnType<typeof Pino>
+
 }
 
 type CreateSdkGenOptions = Partial<FullCreateSdkGenOptions>
 
 
 type GenerateSpec = {
-  watch: string[]
+  name: string // Name of SDK project.
+  def: string // Path to OpenAPI definition file, copied into SDK project.
+  root: string // Path to Root template component.
 }
 
 
@@ -29,109 +31,72 @@ const { each, names, Jostraca } = JostracaModule
 
 function CreateSdkGen(opts: FullCreateSdkGenOptions) {
   const fs = opts.fs || Fs
-  const folder = opts.folder || '.'
+  const pino = prettyPino('create', opts)
+  const log = pino.child({ cmp: 'create' })
+
   const jostraca = Jostraca()
-  const rootpath = opts.rootpath as string
 
-  async function generate(spec: any) {
-    const now = Date.now()
-    // console.log('CREATE SDK', now, new Date(now), spec)
+  async function generate(spec: GenerateSpec) {
+    const start = Date.now()
 
-    const { model } = spec
+    log.info({ point: 'generate-start', start })
+    log.debug({ point: 'generate-spec', spec, note: JSON.stringify(spec, null, 2) })
 
-    const ctx$ = { fs, folder, meta: { spec } }
+    const rootModule: any = require(spec.root)
+    const Root = rootModule.Root
 
-    clear()
-    const { Root } = require(rootpath)
+    const name = spec.name
+    spec.def = (null == spec.def || '' === spec.def) ? name + '-openapi3.yml' : spec.def
 
-    completeModel(model)
+    const folder = Path.join(process.cwd(), name + (name.endsWith('-sdk') ? '' : '-sdk'))
 
-    try {
-      await jostraca.generate(ctx$, () => Root({ model }))
-    }
-    catch (err: any) {
-      console.log('CREATE SDKGEN ERROR: ', err)
-      throw err
+    const opts = {
+      fs: () => fs,
+      folder,
+      log: log.child({ cmp: 'jostraca' }),
+      meta: { spec },
+      existing: {
+        // write: false,
+        // present: true,
+        merge: true
+      }
     }
-  }
-
-
-  async function watch(spec: GenerateSpec) {
-    const fsw = new FSWatcher()
-    let last_change_time = 0
-
-    await generate(spec)
 
-    fsw.on('change', (args: any[]) => {
-      // console.log('CHANGE', args)
+    const model = {
+      name,
+      year: new Date().getFullYear(),
+    }
 
-      const dorun = 1111 < Date.now() - last_change_time
+    names(model, model.name)
 
-      if (dorun) {
-        last_change_time = Date.now()
-        generate(spec)
-      }
-    })
+    log.debug({ point: 'generate-model', model, note: JSON.stringify(model, null, 2) })
 
-    spec.watch
-      .map((wf: string) => (__dirname + '/' + wf))
-      // .map((wf: string) => (console.log(wf), wf))
-      .map((wf: string) => fsw.add(wf))
+    const info = await jostraca.generate(opts, () => Root({ model, spec }))
 
-    // generate()
-  }
+    logfiles(info, log)
 
-
-  function clear() {
-    if (rootpath) {
-      clearRequire(rootpath)
-    }
+    log.info({ point: 'generate-end' })
   }
 
-
   return {
     generate,
-    watch,
   }
 
 }
 
 
-function completeModel(model: any) {
-  names(model, model.name)
+function logfiles(info: any, log: ReturnType<typeof Pino>) {
+  const cwd = process.cwd()
 
-  each(model.feature, (feature: any) => {
-    names(feature, feature.key$)
-  })
-}
-
-
-// Adapted from https://github.com/sindresorhus/import-fresh - Thanks!
-function clearRequire(path: string) {
-  let filePath = require.resolve(path)
-
-  if (require.cache[filePath]) {
-    const children = require.cache[filePath].children.map(child => child.id)
-
-    // Delete module from cache
-    delete require.cache[filePath]
-
-    for (const id of children) {
-      clearRequire(id)
-    }
-  }
-
-
-  if (require.cache[filePath] && require.cache[filePath].parent) {
-    let i = require.cache[filePath].parent.children.length
-
-    while (i--) {
-      if (require.cache[filePath].parent.children[i].id === filePath) {
-        require.cache[filePath].parent.children.splice(i, 1)
+    ;['preserve', 'present', 'merge'].map(action => {
+      let entries = info.file[action]
+      if (0 < entries.length) {
+        log.info({
+          point: 'file-' + action, entries,
+          note: '\n' + entries.map((n: any) => n.path.replace(cwd, '.')).join('\n')
+        })
       }
-    }
-  }
-
+    })
 }
 
 

package/src/standard/ModelSdk.ts

@@ -1,102 +1,25 @@
 
 import {
-  names,
   cmp,
-  each,
-
-  Project,
-  Folder,
-  Fragment,
   File,
-  Content,
+  Fragment,
 
 } from 'jostraca'
 
 
 
 const ModelSdk = cmp(function ModelSdk(props: any) {
-  const { ctx$, ctx$: { model } } = props
-
-
-  // console.log('ModelSdk 2', model)
-
-  // TODO: use apidef
-  // const def = ctx$.fs.readFileSync(model.def.filepath)
+  const { spec } = props
 
 
   File({ name: 'sdk.jsonic' }, () => {
-    Content(`
-
-@"../node_modules/@voxgig/sdkgen/model/sdkgen.jsonic"
-
-name: '${model.name}'
-
-@"api.jsonic"
-@"def.jsonic"
-
-main: sdk: build: &: { name: .$KEY }
-
-main: sdk: build: js: @"js.jsonic"
-
-main: sdk: build: rb: @"rb.jsonic"
-
-main: sdk: build: py: @"py.jsonic"
-
-main: sdk: build: php: @"php.jsonic"
-
-main: sdk: build: go: @"go.jsonic"
-
-
-
-main: sdk: test: quick: entity: name: foo
-
-
-main: sdk: entity: $.main.api.entity
-
-
-
-main: sdk: option: {
-
-  endpoint: {
-    kind: *String | string
-    short: "${model.Name} API URL"
-  }
-
-  apikey: {
-    kind: *String | string
-    short: "${model.Name} API Key"
-  }
-  
-  fetch: {
-    kind: *Any | string
-    publish: false
-  }
-}
-`)
-
-
-    each(model.feature).filter((feature: any) => feature.active).map((feature: any) => {
-
-      Content(
-        `
-main: sdk: feature: ${feature.name}: {
-  active: true
-  config: {
-`)
-
-      Fragment({
-        from:
-          `${__dirname}/../../feature/standard/${feature.name}/${feature.name}-config.jsonic`,
-        indent: '    '
-      })
-
-      Content(`
-  } 
-}
-
-`)
+    Fragment({
+      from: __dirname + '/../../project/.sdk/model/sdk.fragment.jsonic',
+      replace: {
+        NAME: spec.name,
+        DEF: spec.def,
+      }
     })
-
   })
 
 })

package/src/standard/Root.ts

@@ -1,12 +1,11 @@
 
 
 import Path from 'node:path'
-
+import * as Fs from 'node:fs'
 
 import {
   names,
   cmp,
-  each,
 
   Project,
   Folder,
@@ -22,44 +21,42 @@ import { ModelSdk } from './ModelSdk'
 
 // TODO: rename to RootSdk
 const Root = cmp(function Root(props: any) {
-  const { model, ctx$ } = props
-
-  const { folder, meta } = ctx$
-  const { spec } = meta
+  const { ctx$, ctx$: { folder }, spec, model } = props
 
-  // names(model, model.name)
+  // TODO: move to @voxgig/util as duplicated
+  model.const = { name: model.name }
+  names(model.const, model.name)
+  model.const.year = new Date().getFullYear()
 
   ctx$.model = model
 
   Project({ folder }, () => {
-
-    // console.log('FOLDER', folder)
     Copy({
-      from: __dirname + '/../../tm/standard',
-      exclude: ['.env.local']
+      from: __dirname + '/../../project',
     })
 
-    const def = model.def.filepath
-    if (null != def && '' !== def) {
+    const origdef = spec.def
+    const projdef = Path.basename(origdef)
+    spec.def = projdef
+
+    Folder({ name: '.sdk' }, () => {
       Folder({ name: 'def' }, () => {
-        Copy({ from: def, name: Path.basename(def) })
+        if (Fs.existsSync(origdef)) {
+          Copy({ from: origdef, to: projdef })
+        }
+        else {
+          File({ name: projdef }, () => {
+            Content('# OpenAPI Definition')
+          })
+        }
       })
-    }
 
-    Folder({ name: 'model' }, () => {
-      ModelSdk({})
-    })
-
-    Folder({ name: 'feature' }, () => {
-      each(model.feature).map((feature: any) => {
-        Folder({ name: feature.name }, () => {
-          Copy({ from: __dirname + '/../../feature/standard/' + feature.name })
-        })
+      Folder({ name: 'model' }, () => {
+        ModelSdk({ spec })
       })
     })
 
   })
-
 })
 
 

package/bin/run-create-sdkgen.js

@@ -1,330 +0,0 @@
-#!/usr/bin/env node
-
-const Path = require('node:path')
-const { statSync } = require('node:fs')
-const { parseArgs } = require('node:util')
-
-const { Gubu, Fault } = require('gubu')
-const { Aontu, Context } = require('aontu')
-
-
-const Pkg = require('../package.json')
-
-const { CreateSdkGen } = require('../dist/create-sdkgen.js') 
-
-// const { Root } = require('../dist/standard/Root')
-const rootpath = require.resolve('../dist/standard/Root')
-
-let DEBUG = false
-let CONSOLE = console
-
-
-try {
-  let options = resolveOptions()
-
-  if(options.debug) {
-    DEBUG = true
-  }
-
-  if(options.version) {
-    version()
-  }
-
-  if(options.help) {
-    help()
-  }
-
-  if(options.version || options.help) {
-    exit()
-  }
-
-  options = validateOptions(options)
-
-  generate(options)
-  
-}
-catch(err) {
-  handleError(err)
-}
-
-
-
-function exit(err) {
-  let code = 0
-  if(err) {
-    code = 1
-  }
-  process.exit(code)
-}
-
-
-function generate(options) {
-  const createSdkGen = CreateSdkGen({
-    folder: options.folder,
-    rootpath
-  })
-
-
-  const model = resolveModel(options)
-    
-  const spec = {
-    // TODO: move to CreateSdkGen options
-    spec: options.spec,
-    model,
-    // root: Root,
-  }
-  
-  if(options.watch) {
-    spec.watch = [
-      '../tm',
-      '../feature',
-      '../def',
-      '../dist',
-    ]
-    createSdkGen.watch(spec)
-  }
-  else {
-    createSdkGen.generate(spec)
-  }
-
-}
-
-
-function resolveModel(options) {
-
-  const typespec = `
-name: string
-year: number
-def: filepath: string
-feature: &: {
-  active: *false | boolean
-}
-`
-
-  const features = options.feature.map(name=>`feature:${name}:active:true`)
-  
-  const src = [
-    typespec,
-    `name: ${options.name}`,
-    `year: ${new Date().getFullYear()}`,
-    `def: filepath: "${options.def || 'def.yml'}"`,
-    '' === options.model ? '' : `@"${options.model}"`,
-    ...(options.set||[]),
-    ...(features||[]),
-  ].join('\n')
-  const aopts = {}
-  const root = Aontu(src, aopts)
-  const hasErr = root.err && 0 < root.err.length
-
-  // TODO: collect all errors
-  if (hasErr) {
-    // console.log('ERROR ROOT', root.err)
-    throw root.err[0].msg
-  }
-
-  let genctx = new Context({ root })
-  const model = root.gen(genctx)
-
-  // TODO: collect all errors
-  if (genctx.err && 0 < genctx.err.length) {
-    // console.log(genctx.err)
-    // console.log('ERROR GEN', genctx.err)
-    throw new Error(JSON.stringify(genctx.err[0]))
-  }
-  
-  model.def.filename = Path.basename(model.def.filepath)
-
-  // console.log('MODEL')
-  // console.dir(model,{depth:null})
-  
-  return model
-}
-
-
-function resolveOptions() {
-
-  const args = parseArgs({
-    allowPositionals: true,
-    options: {
-      folder: {
-        type: 'string',
-        short: 'f',
-        default: '',
-      },
-      
-      def: {
-        type: 'string',
-        short: 'd',
-        default: '',
-      },
-      
-      set: {
-        type: 'string',
-        short: 's',
-        multiple: true,
-      },
-
-      model: {
-        type: 'string',
-        short: 'm',
-        default: '',
-      },
-      
-      feature: {
-        type: 'string',
-        short: 't',
-        multiple: true,
-      },
-      
-      watch: {
-        type: 'boolean',
-        short: 'w',
-      },
-      
-      debug: {
-        type: 'boolean',
-        short: 'g',
-      },
-      
-      help: {
-        type: 'boolean',
-        short: 'h',
-      },
-      
-      version: {
-        type: 'boolean',
-        short: 'v',
-      },
-      
-    }
-  })
-
-  const options = {
-    name: args.positionals[0],
-    folder: '' === args.values.folder ? args.positionals[0] : args.values.folder,
-    def: args.values.def,
-    model: args.values.model,
-    feature: args.values.feature,
-    set: args.values.set,
-    watch: !!args.values.watch,
-    debug: !!args.values.debug,
-    help: !!args.values.help,
-    version: !!args.values.version,
-  }
-
-  return options
-}
-
-
-function validateOptions(rawOptions) {
-  const optShape = Gubu({
-    name: Fault('The first argument should be the project name.', String),
-    folder: String,
-    def: '',
-    model: '',
-    feature: [String],
-    set: [String],
-    watch: Boolean,
-    debug: Boolean,
-    help: Boolean,
-    version: Boolean,
-  })
-
-  const err = []
-  const options = optShape(rawOptions,{err})
-
-  if(err[0]) {
-    throw new Error(err[0].text)
-  }
-
-  if('' !== options.def) {
-    options.def = Path.resolve(options.def)
-    const stat = statSync(options.def, {throwIfNoEntry:false})
-    if(null == stat) {
-      throw new Error('Definition file not found: '+options.def)
-    }
-  }
-
-  if('' !== options.model) {
-    options.model = Path.resolve(options.model)
-    const stat = statSync(options.model, {throwIfNoEntry:false})
-    if(null == stat) {
-      throw new Error('Model file not found: '+options.model)
-    }
-  }
-
-  return options
-}
-
-
-function handleError(err) {
-  CONSOLE.log('Voxgig SDK Generator Error:')
-
-  if(DEBUG) {
-    CONSOLE.log(err)
-  }
-  else {
-    CONSOLE.log(err.message)
-  }
-  
-  exit(err)
-}
-
-
-function version() {
-  CONSOLE.log(Pkg.version)
-}
-
-
-function help() {
-  let s = `
-Create a Voxgig SDK Generator project.
-
-Usage: npm create @voxgig/sdkgen@latest <name> <args> 
-
-  where <name> is the name of the SDK project. This is also used to
-    create a project folder if one is not explictly defined using the -f
-    argument. If run against an existing folder generated files will be
-    overwritten.
-
-  <args> are the command arguments:
-
-    --folder <folder>      Specific the folder for the SDK project. Optional.
-    -f <folder>              Default: <name> in current folder.
-
-    --def <file>           Specify the API definition file (OpenAPI, Swagger, etc)
-    -d                       that defines the SDK. Optional.
-
-    --model <file>         Specify the SDK model file to customize the SDK. Optional.
-    -m                       
-
-    --watch                Run in watch mode. The SDK project will be updated if any of the
-    -w                       project inputs (such as the spec file) change.
-
-    --debug                Print verbose logging.
-    -d                       
-
-    --help                 Print this help message.
-    -h
-
-    --version              Print version number.
-    -v
-
-
-Examples:
-
-# Basic usage
-> npm create @voxgig/sdkgen@latest foo
-# Creates the SDK Project in the folder ./foo
-
-
-# Custom project folder
-> npm create @voxgig/sdkgen@latest foo -f ~/Projects/Foo
-# Creates the SDK Project in the folder ~/Projects/Foo
-
-
-See also: https://voxgig.com/sdkgen
-`
-
-  CONSOLE.log(s)
-}

package/bin/run-create-sdkgen.js~

@@ -1 +0,0 @@
-