@voxgig/create-sdkgen 0.0.1 → 0.0.3

package/tm/standard/src/py/TestMain_py.ts

@@ -0,0 +1,103 @@
+
+import { cmp, each, File, Content } from '@voxgig/sdkgen'
+
+
+import { TestEntity } from './TestEntity_py'
+
+
+const TestMain = cmp(function TestMain(props: any) {
+  const { build } = props
+  const { model } = props.ctx$
+
+  File({ name: 'Fetch.' + build.extension }, () => {
+
+    Content(`
+import json
+
+def fetch(url, config):
+    parts = url.split("/")
+    # print('parts: ', parts)
+    entname = None
+    entid = None
+
+    try:
+        # TODO: PARTS DEPEND ON THE SWAGGERS: add logic
+        # A utility for url parsing is needed
+        entname = parts[1]
+        entid = parts[2]
+    except IndexError:
+        pass
+
+    data = config.get("body") or {}
+    method = config.get("method") or "GET"
+
+    req = {
+        "url": url,
+        "parts": parts,
+        "entname": entname,
+        "entid": entid,
+        "method": method,
+        "data": data,
+    }
+
+    json_data = None
+    if "GET" == method:
+        if None != entid:
+            json_data = {"id": entid, "title": "T01"}
+        else:
+            json_data = {
+                "name": entname,
+                "list": [{"id": "n01", "title": "N01"}, {"id": "n02", "title": "N02"}],
+            }
+    elif "PUT" == method or "POST" == method:
+        if None != entid:
+            json_data = { "id": entid, "title": data.get('title') }
+        else:
+            json_data = { "id": "n03", "title": data.get('title') or "T03" }
+
+    return {"req": req, "status": 200, "json": json_data}
+`)
+
+  })
+
+  File({ name: 'test_' + model.name + '_sdk.' + build.extension }, () => {
+
+    Content(`
+import json
+
+from dotenv import dotenv_values
+
+import ${model.name}_sdk
+
+from ${model.name}_sdk import Config
+
+from Fetch import fetch
+
+
+def makeClient(config = {}):
+    client = ${model.name}_sdk.${model.Name}SDK.make(Config(
+        endpoint=config.get('${model.NAME}_ENDPOINT'),
+        apikey=config.get('${model.NAME}_APIKEY'),
+        fetch=fetch
+    ))
+    return client
+
+`)
+    Content(`
+def test_happy():
+    config = dotenv_values('.env.test.local')
+    client = makeClient(config)
+    `)
+    each(model.main.sdk.entity, (entity: any) => {
+      TestEntity({ model, build, entity })
+    })
+
+
+  })
+})
+
+
+export {
+  TestMain
+}
+

package/tm/standard/src/py/Test_py.ts

@@ -0,0 +1,28 @@
+import { cmp, File, Content, Folder } from '@voxgig/sdkgen'
+
+
+import { Quick } from './Quick_py'
+import { TestMain } from './TestMain_py'
+import { TestAccept } from './TestAccept_py'
+
+
+const Test = cmp(function Test_(props: any) {
+  const { build } = props
+
+  Folder({ name: 'tests' }, () => {
+
+    Quick({ build })
+    TestMain({ build })
+
+    Folder({ name: 'accept' }, () => {
+      TestAccept({ build })
+    })
+
+  })
+
+})
+
+
+export {
+  Test
+}

package/tm/standard/src/rb/Client_rb.ts

@@ -0,0 +1,142 @@
+import {
+  cmp,
+  each,
+  camelify,
+  File,
+  Content,
+  Folder,
+  snakify,
+} from '@voxgig/sdkgen';
+
+
+import { MainEntity } from './MainEntity_rb'
+
+
+const Client = cmp(async function Client(props: any) {
+  const { build } = props;
+  const { model } = props.ctx$;
+
+  const entity = model.main.sdk.entity;
+
+  Folder({ name: "lib" }, () => {
+    Folder({ name: snakify(model.Name) + "_sdk" }, () => {
+      File({ name: "client.rb" }, () => {
+        Content(`
+# ${model.Name} ${build.Name} SDK
+
+require 'json'
+require 'net/http'
+        `);
+
+        each(entity, (entity: any) => {
+          entity.Name = camelify(entity.name);
+          Content(`
+require_relative './${snakify(entity.Name)}'
+        `);
+        });
+
+        const validate_options = each(build.options).reduce(
+          (a: string, opt: any) =>
+            a +
+            ("String" === opt.kind
+              ? `    required('String','${opt.name}', @options)\n`
+              : ""),
+          ""
+        );
+
+        Content(`
+module ${model.Name}SDK       
+  class Client
+    attr_reader :options
+
+    def initialize(opts = {})
+        @options = ${model.Name}SDK.options.merge(opts)
+            ${validate_options}
+        @options[:fetch] ||= ->(url, method, apikey, body = nil) {
+            default_fetch(url, method, apikey, body)
+        }
+    end
+
+    def endpoint(op, ent)
+        data = ent.data
+        definition = ent.def
+        base_url = "#{options[:endpoint]}/#{definition[:name]}"
+
+        if (op == 'load' || op == 'remove') && data[:id] != nil
+            "#{base_url}/#{data[:id]}"
+        else
+            base_url
+        end
+    end
+
+    def method(op, ent)
+        ent.nil? && op == 'save' ? 'create' : op
+        {
+            'create' => 'POST',
+            'save' => 'PUT',
+            'load' => 'GET',
+            'list' => 'GET',
+            'remove' => 'DELETE'
+        }[op]
+    end
+
+    def body(op, ent)
+        msg = ent.data.dup
+        JSON.generate(msg)
+    end
+        
+        `);
+
+        each(entity, (entity: any) => {
+          MainEntity({ model, build, entity });
+        });
+
+        Content(`
+        
+    private
+            
+    def required(type, name, options)
+      val = options[name.to_sym]
+      unless val.is_a?(Object.const_get(type))
+          raise ArgumentError, "${model.Name}SDK: Invalid option: #{name}=#{val}: must be of type #{type}"
+      end
+    end
+
+    def default_fetch(url, method, apikey, body = nil)
+      uri = URI(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = (uri.scheme == "https")
+
+      request = build_request(uri, method, apikey, body)
+
+      begin
+          response = http.request(request)
+          response 
+      rescue SocketError => e
+          raise ${model.Name}NetworkError.new("Network unreachable: #{e.message}")
+      rescue Timeout::Error => e
+          raise ${model.Name}TimeoutError.new("Request timed out: #{e.message}")
+      rescue StandardError => e
+          raise ${model.Name}SDKError.new("Unexpected error: #{e.message}")
+      end
+    end
+
+    def build_request(uri, method, apikey, body)
+      request = Net::HTTP.const_get(method.capitalize).new(uri)
+      request['Content-Type'] = 'application/json'
+      request['Authorization'] = "Bearer #{apikey}"
+      request.body = body if %i[post put].include?(method.downcase.to_sym) && body
+      request
+    end
+  end
+end
+        
+        `);
+      });
+    });
+  });
+});
+
+
+export { Client };
+

package/tm/standard/src/rb/Entity_rb.ts

@@ -0,0 +1,153 @@
+import {
+  cmp,
+  File,
+  Content,
+  Folder,
+  snakify,
+} from '@voxgig/sdkgen';
+
+const Entity = cmp(function Entity(props: any) {
+  const { build, entity } = props;
+  const { model } = props.ctx$;
+
+  Folder({ name: "lib" }, () => {
+    Folder({ name: snakify(model.Name) + "_sdk" }, () => {
+      File({ name: snakify(entity.Name) + ".rb" }, () => {
+        Content(`
+# ${model.Name} ${build.Name} ${entity.Name}
+
+require 'json'
+require 'net/http'
+
+class ${entity.Name}
+  attr_accessor :sdk, :def, :data
+
+  def initialize(sdk, data = nil)
+    @sdk = sdk
+    @def = {
+      name: "${entity.name}"
+    }
+    @data = data
+  end
+
+  def handle_result(op, res, spec)
+    status = res.code.to_i
+
+    case status
+    when 200
+      json = JSON.parse(res.body, symbolize_names: true)
+      yield(json)
+    when 400
+      raise ${model.Name}BadRequestError.new("Bad request", status, res.body)
+    when 401
+      raise ${model.Name}AuthenticationError.new("Authentication failed", status, res.body)
+    when 404
+      raise ${model.Name}NotFoundError.new("Resource not found", status, res.body)
+    when 429
+      raise ${model.Name}RateLimitError.new("Rate limit exceeded", status, res.body)
+    when 400..499
+      raise ${model.Name}ClientError.new("Client error", status, res.body)
+    when 500..599
+      raise ${model.Name}ServerError.new("Server error", status, res.body)
+    else
+      raise ${model.Name}SDKError.new("HTTP-ERROR: #{op}: ${entity.name}: #{status}", status, res.body)
+    end
+  end
+
+  def save(data)
+    op = 'save'
+    self.data = data
+    # TODO: validate data
+
+    body = sdk.body('save', self)
+    method = sdk.method('save', self)
+    url = sdk.endpoint('save', self)
+    
+    spec = {}
+    res = sdk.options[:fetch].call(url, method, sdk.options[:apikey], body)
+
+    handle_result(op, res, spec) do |json|
+      self.data = json
+      self
+    end
+  end
+
+  def create(data)
+    op = 'create'
+    self.data = data
+
+    body = sdk.body('create', self)
+    method = sdk.method('create', self)
+    url = sdk.endpoint('create', self)
+
+    spec = {}
+    res = sdk.options[:fetch].call(url, method, sdk.options[:apikey], body)
+
+    handle_result(op, res, spec) do |json|
+      self.data = json
+      self
+    end
+  end
+
+  def load(data)
+    op = 'load'
+    self.data = data
+    # TODO: check if data.id is defined
+
+    body = sdk.body('load', self)
+    method = sdk.method('load', self)
+    url = sdk.endpoint('load', self)
+
+    spec = {}
+    res = sdk.options[:fetch].call(url, method, sdk.options[:apikey], body)
+
+    handle_result(op, res, spec) do |json|
+      self.data = json
+      self
+    end
+  end
+
+  def list(data = {})
+    op = 'list'
+    self.data = data
+    # TODO: check if data.id is defined
+
+    body = sdk.body('load', self)
+    method = sdk.method('load', self)
+    url = sdk.endpoint('load', self)
+
+    spec = {}
+    res = sdk.options[:fetch].call(url, method, sdk.options[:apikey], body)
+
+    handle_result(op, res, spec) do |json|
+      return json[:list].map { |data| sdk.${entity.Name}(data) }
+    end
+  end
+
+  def remove(data)
+    op = 'remove'
+    self.data = data
+
+    body = sdk.body('remove', self)
+    method = sdk.method('remove', self)
+    url = sdk.endpoint('remove', self)
+
+    spec = {}
+    res = sdk.options[:fetch].call(url, method, sdk.options[:apikey], body)
+
+    handle_result(op, res, spec) do |json|
+      self.data = json
+      self
+    end
+  end
+
+end
+
+`);
+      });
+    });
+  });
+});
+
+
+export { Entity };

package/tm/standard/src/rb/Error_rb.ts

@@ -0,0 +1,56 @@
+import {
+  cmp,
+  File,
+  Content,
+  Folder,
+  snakify,
+} from '@voxgig/sdkgen';
+
+const Error = cmp(function Error(props: any) {
+  const { build, entity } = props;
+  const { model } = props.ctx$;
+
+  Folder({ name: "lib" }, () => {
+    Folder({ name: snakify(model.Name) + "_sdk" }, () => {
+      File({ name: "errors.rb" }, () => {
+        Content(`
+
+module ${model.Name}SDK
+  class ${model.Name}SDKError < StandardError
+    attr_reader :status, :body, :response
+    
+    def initialize(message, status = nil, body = nil, response = nil)
+      super(message)
+      @status = status
+      @body = body
+      @response = response
+    end
+
+    def to_s
+      "#{message} (status: #{status || 'N/A'}, response body: #{body || 'N/A'})"
+    end
+  end
+
+  # Network errors
+  class ${model.Name}NetworkError < ${model.Name}SDKError; end
+  class ${model.Name}TimeoutError < ${model.Name}SDKError; end
+
+  # API errors
+  class ${model.Name}BadRequestError < ${model.Name}SDKError; end
+  class ${model.Name}AuthenticationError < ${model.Name}SDKError; end
+  class ${model.Name}NotFoundError < ${model.Name}SDKError; end
+  class ${model.Name}RateLimitError < ${model.Name}SDKError; end
+  class ${model.Name}ClientError < ${model.Name}SDKError; end
+  class ${model.Name}ServerError < ${model.Name}SDKError; end
+end
+
+
+
+`);
+      });
+    });
+  });
+});
+
+
+export { Error };

package/tm/standard/src/rb/MainEntity_rb.ts

@@ -0,0 +1,16 @@
+import { cmp, Content } from '@voxgig/sdkgen';
+
+const MainEntity = cmp(async function MainEntity(props: any) {
+  const { entity } = props;
+
+  const def = JSON.stringify(entity);
+
+  Content(`
+  def ${entity.Name}(data={})
+    ${entity.Name}.new(self, data)
+  end
+
+`);
+});
+
+export { MainEntity };

package/tm/standard/src/rb/Main_rb.ts

@@ -0,0 +1,55 @@
+import {
+  cmp,
+  File,
+  Content,
+  Copy,
+  Folder,
+  snakify,
+} from '@voxgig/sdkgen';
+
+import { Test } from "./Test_rb";
+import { Error } from "./Error_rb";
+import { Client } from './Client_rb';
+
+const Main = cmp(async function Main(props: any) {
+  const { build } = props;
+  const { model } = props.ctx$;
+
+  Copy({ from: "tm/" + build.name + "/Gemfile", name: "Gemfile" });
+  Copy({ from: "tm/" + build.name + "/" + 'tm.gemspec', name: snakify(model.Name) + "_sdk.gemspec" });
+  Copy({ from: "tm/" + build.name + "/Rakefile", name: "Rakefile" });
+
+  Test({ build });
+  Error({ model, build });
+  Client({ model, build });
+
+  Folder({ name: "lib" }, () => {
+    File({ name: snakify(model.Name) + "_sdk.rb" }, () => {
+      Content(`
+# ${model.Name} ${build.Name} SDK
+`);
+
+      Content(`
+
+require_relative "${model.name}_sdk/client"
+
+module ${model.Name}SDK
+  class << self
+    attr_accessor :options
+
+    def options
+      @options ||= {}
+    end
+
+    def configure
+      yield self
+    end
+  end
+end
+      `);
+    });
+  });
+});
+
+
+export { Main };

package/tm/standard/src/rb/Quick_rb.ts

@@ -0,0 +1,65 @@
+import { cmp, File, Content } from '@voxgig/sdkgen';
+
+const Quick = cmp(function Quick(props: any) {
+  const { build } = props;
+  const { model } = props.ctx$;
+
+  File({ name: "quick.rb" }, () => {
+    Content(`
+require 'dotenv'
+Dotenv.load
+require_relative '../lib/${model.name}_sdk'
+
+def run
+
+  client = ${model.Name}SDK::Client.new(
+    {
+      endpoint: ENV['${model.NAME}_ENDPOINT'],
+      apikey: ENV['${model.NAME}_APIKEY'],
+    }
+  )
+
+  # Test listing assets
+  out = client.Geofence.list()
+  puts "Geofence.list: #{out.inspect}\n\n"
+
+  # Test loading an asset
+  out = client.Geofence.load({id: 1})
+  puts "Geofence.load: #{out.inspect}\n\n"
+
+  # Check if endpoint includes localhost 
+  if ENV['${model.NAME}_ENDPOINT'].include? 'localhost'
+    # Test creating an asset
+    out = client.Geofence.create({
+      id: 'CF49B47C-317B-4387-83C3-4A23715B1C45',
+      name: 'Geofence 1',
+      desc: 'Geofence 1 description',
+      custom: { foo: 'bar' },
+      extent_id: 'CF49B47C-317B-4387-83C3-4A23715B1C45'
+    })
+    puts "Geofence.create: #{out.inspect}\n\n"
+  
+    # Test updating an asset
+    out = client.Geofence.save({
+      id: 'CF49B47C-317B-4387-83C3-4A23715B1C45',
+      name: 'Geofence 1',
+      desc: 'Geofence 1 description',
+      custom: { foo: 'bar' },
+      extent_id: 'CF49B47C-317B-4387-83C3-4A23715B1C45'
+    })
+    puts "Geofence.save: #{out.inspect}\n\n"
+
+    # Test deleting an asset
+    out = client.Geofence.remove({id: 'CF49B47C-317B-4387-83C3-4A23715B1C45'})
+    puts "Geofence.remove: #{out.inspect}\n\n"
+   
+  end
+end
+
+run
+
+`);
+  });
+});
+
+export { Quick };

package/tm/standard/src/rb/ReadmeInstall_rb.ts

@@ -0,0 +1,19 @@
+
+import { cmp, Content } from '@voxgig/sdkgen'
+
+
+const ReadmeInstall = cmp(function ReadmeInstall(props: any) {
+  const { build } = props
+
+  Content('```ruby')
+  Content(`
+gem install ${build.module.name}
+`)
+  Content('```')
+
+})
+
+
+export {
+  ReadmeInstall
+}

package/tm/standard/src/rb/ReadmeQuick_rb.ts

@@ -0,0 +1,30 @@
+
+import { cmp, Content } from '@voxgig/sdkgen'
+
+
+const ReadmeQuick = cmp(function ReadmeQuick(props: any) {
+  const { build, ctx$: { model } } = props
+
+  Content('```ruby')
+  Content(`
+require('${build.module.name}')
+
+client = ${model.Name}SDK::Client.new(
+    {
+      endpoint: ENV['${model.NAME}_ENDPOINT'],
+      apikey: ENV['${model.NAME}_APIKEY'],
+    }
+  )
+
+  # List all buildings
+  buildings = client.Building.list()
+  puts "Buildings: #{buildings.inspect}"
+`)
+  Content('```')
+
+})
+
+
+export {
+  ReadmeQuick
+}