@voxgig/create-sdkgen 0.0.2 → 0.0.3

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
+}

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

@@ -0,0 +1,83 @@
+
+import { cmp, camelify, Content } from '@voxgig/sdkgen'
+
+
+const TestAcceptEntity = cmp(function TestEntity(props: any) {
+  const { entity } = props
+
+  entity.Name = camelify(entity.name)
+
+  Content(`
+    describe '${entity.name}-load' do
+      it 'loads the entity correctly' do
+        out = @client.${entity.Name}.load(id: 't01')
+        # puts '${entity.name}-load', out
+
+        expect(out.data).to be_a(Hash)
+      end
+    end
+
+    describe '${entity.name}-list' do
+      it 'lists the entity correctly' do
+        out = @client.${entity.Name}.list
+        # puts '${entity.name}-list', out
+
+        expect(out).to be_a(Array)
+      end
+    end
+
+    describe '${entity.name}-create' do
+      it 'creates the entity correctly' do
+        out = @client.${entity.Name}.create(${JSON.stringify(generateObjectFromFields(entity.field))})
+        # puts '${entity.name}-create', out
+
+        expect(out.data).to be_a(Hash)
+      end
+    end 
+
+    describe '${entity.name}-save' do
+      it 'saves the entity correctly' do
+        out = @client.${entity.Name}.save(${JSON.stringify(generateObjectFromFields(entity.field))})
+        # puts '${entity.name}-save', out
+
+        expect(out.data).to be_a(Hash)
+      end
+    end
+
+    describe '${entity.name}-remove' do
+      it 'removes the entity correctly' do
+        out = @client.${entity.Name}.remove(id: 't01')
+        # puts '${entity.name}-remove', out
+
+        expect(out.data).to be_a(Hash)
+      end
+    end
+    
+  `);
+})
+
+function generateObjectFromFields(fields: any) {
+  const getRandomString = (length: number): string =>
+    Array.from({ length }, () => 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'.charAt(Math.floor(Math.random() * 62))).join('');
+
+  const defaultValues: Record<string, any> = {
+    number: Math.floor(Math.random() * 100),
+    string: getRandomString(5),
+    object: { [getRandomString(3)]: getRandomString(3) },
+    boolean: Math.random() > 0.5,
+    array: Array.from({ length: 3 }, () => getRandomString(3)),
+  }
+
+  const result: Record<string, any> = {}
+
+  for (const key in fields) {
+    result[key] = defaultValues[fields[key].type] ?? null;
+  }
+
+  return result
+}
+
+
+export {
+  TestAcceptEntity
+}

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

@@ -0,0 +1,45 @@
+
+import { cmp, each, File, Content } from '@voxgig/sdkgen'
+
+
+import { TestAcceptEntity } from "./TestAcceptEntity_rb"
+
+
+const TestAccept = cmp(function TestMain_js(props: any) {
+  const { build } = props
+  const { model } = props.ctx$
+
+
+  File({ name: model.name + '_sdk_spec.rb' }, () => {
+
+    Content(`
+      RSpec.describe '${model.Name}SDK::Client Acceptance Tests' do 
+        before(:each) do
+          @client = ${model.Name}SDK::Client.new(
+            apikey: ENV['${model.NAME}_APIKEY'],
+            endpoint: ENV['${model.NAME}_ENDPOINT']
+          )
+        end
+
+        it 'happy' do
+          out = @client.Geofence.load(id: 'gf01')
+          # puts 'Geofence-load', out.inspect
+          expect(out.data[:id]).to eq('gf01')
+        end
+    `)
+
+    each(model.main.sdk.entity, (entity: any) => {
+      TestAcceptEntity({ model, build, entity })
+    })
+
+    Content(`end`)
+
+
+  })
+})
+
+
+export {
+  TestAccept
+}
+