RubyGems - tina4ruby - Versions diffs - 3.13.39 → 3.13.41 - Mend

tina4ruby 3.13.39 → 3.13.41

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

checksums.yaml +4 -4
data/lib/tina4/auth.rb +5 -1
data/lib/tina4/dev_admin.rb +79 -12
data/lib/tina4/docstore.rb +753 -0
data/lib/tina4/env.rb +7 -2
data/lib/tina4/mcp.rb +92 -20
data/lib/tina4/queue.rb +31 -5
data/lib/tina4/queue_backends/lite_backend.rb +158 -20
data/lib/tina4/queue_backends/mongo_backend.rb +76 -2
data/lib/tina4/rack_app.rb +16 -4
data/lib/tina4/swagger.rb +166 -32
data/lib/tina4/version.rb +1 -1
data/lib/tina4.rb +1 -0
metadata +3 -2

data/lib/tina4/rack_app.rb CHANGED Viewed

@@ -454,17 +454,26 @@ module Tina4
     end
     def serve_swagger_ui
+      # Honour the documented production on/off switch (TINA4_SWAGGER_ENABLED,
+      # else TINA4_DEBUG) — before v3.13.40 this was never checked and /swagger
+      # (the full API surface) was served unconditionally in production.
+      return [404, { "content-type" => "text/plain" }, ["Not Found"]] unless Tina4::Swagger.enabled?
+      # The UI assets load from a CDN by default (keeps the framework
+      # zero-dependency — no vendored ~1.4MB swagger-ui-dist). Air-gapped
+      # deployments point TINA4_SWAGGER_UI_CDN at a self-hosted mirror.
+      cdn = (ENV["TINA4_SWAGGER_UI_CDN"] || "https://cdn.jsdelivr.net/npm/swagger-ui-dist@5").sub(%r{/+\z}, "")
       html = <<~HTML
         <!DOCTYPE html>
         <html lang="en">
         <head>
           <meta charset="UTF-8">
           <title>API Documentation</title>
-          <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui.css">
+          <link rel="stylesheet" href="#{cdn}/swagger-ui.css">
         </head>
         <body>
           <div id="swagger-ui"></div>
-          <script src="https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui-bundle.js"></script>
+          <script src="#{cdn}/swagger-ui-bundle.js"></script>
           <script>
             SwaggerUIBundle({ url: '/swagger/openapi.json', dom_id: '#swagger-ui' });
           </script>
@@ -475,8 +484,11 @@ module Tina4
     end
     def serve_openapi_json
-      @openapi_json ||= JSON.generate(Tina4::Swagger.generate)
-      [200, { "content-type" => "application/json; charset=utf-8" }, [@openapi_json]]
+      return [404, { "content-type" => "application/json; charset=utf-8" }, ['{"error":"Not Found"}']] unless Tina4::Swagger.enabled?
+      # Regenerate per request — DevReload adds routes in-process (same PID), so
+      # a memoized spec would go stale until restart. Swagger.generate is cheap.
+      [200, { "content-type" => "application/json; charset=utf-8" }, [JSON.generate(Tina4::Swagger.generate)]]
     end
     def handle_403(path = "")

data/lib/tina4/swagger.rb CHANGED Viewed

@@ -7,14 +7,28 @@ module Tina4
       def generate(routes = [])
         spec = base_spec
         route_list = routes.empty? ? Tina4::Router.routes : routes
+        # Accumulators shared across routes: ORM models referenced
+        # (-> components.schemas), tags used (-> top-level tags[]), seen
+        # operationIds (de-dup — OpenAPI requires them unique).
+        ctx = { models: {}, used_tags: [], seen_ids: [] }
         route_list.each do |route|
-          add_route_to_spec(spec, route)
+          add_route_to_spec(spec, route, ctx)
         end
+        unless ctx[:models].empty?
+          spec["components"]["schemas"] = {}
+          ctx[:models].each do |name, klass|
+            spec["components"]["schemas"][name] = model_schema(klass)
+          end
+        end
+        spec["tags"] = ctx[:used_tags].map { |t| { "name" => t } } unless ctx[:used_tags].empty?
         spec
       end
-      # TINA4_SWAGGER_ENABLED — defaults to TINA4_DEBUG. When false, callers
-      # can choose to skip mounting /swagger entirely in production.
+      # TINA4_SWAGGER_ENABLED — defaults to TINA4_DEBUG. Wired into RackApp's
+      # /swagger serving (v3.13.40), so it genuinely gates whether the docs are
+      # served — it was dead code before.
       def enabled?
         explicit = ENV["TINA4_SWAGGER_ENABLED"]
         if explicit && !explicit.empty?
@@ -51,9 +65,7 @@ module Tina4
         {
           "openapi" => "3.0.3",
           "info" => info,
-          "servers" => [
-            { "url" => "/" }
-          ],
+          "servers" => servers,
           "paths" => {},
           "components" => {
             "securitySchemes" => {
@@ -67,48 +79,125 @@ module Tina4
         }
       end
-      def add_route_to_spec(spec, route)
-        path = convert_path(route.path)
+      # servers[] — TINA4_SWAGGER_SERVERS (comma-separated) for a multi-server
+      # list, else SWAGGER_DEV_URL, else the relative "/" default.
+      def servers
+        raw = ENV.fetch("TINA4_SWAGGER_SERVERS", "")
+        urls = raw.split(",").map(&:strip).reject(&:empty?)
+        return urls.map { |u| { "url" => u } } unless urls.empty?
+        dev = ENV["SWAGGER_DEV_URL"]
+        return [{ "url" => dev }] if dev && !dev.empty?
+        [{ "url" => "/" }]
+      end
+      # Valid OpenAPI path-item methods. Anything else (e.g. "any", a WebSocket
+      # "ws") is not a valid key and would make the document spec-invalid.
+      HTTP_METHODS = %w[get post put patch delete head options trace].freeze
+      def add_route_to_spec(spec, route, ctx)
         method = route.method.downcase
-        return if method == "any"
+        return unless HTTP_METHODS.include?(method)
+        path = convert_path(route.path)
+        meta = route.swagger_meta || {}
+        # ORM model -> components.schemas + $ref
+        ref = nil
+        if (model = meta[:model])
+          klass = model.is_a?(String) ? resolve_model(model) : model
+          if klass
+            name = klass.name.split("::").last
+            ctx[:models][name] ||= klass
+            ref = "#/components/schemas/#{name}"
+          end
+        end
+        tags = meta[:tags] || [extract_tag(route.path)]
+        tags.each { |t| ctx[:used_tags] << t unless ctx[:used_tags].include?(t) }
         spec["paths"][path] ||= {}
         operation = {
-          "summary" => route.swagger_meta[:summary] || "#{method.upcase} #{route.path}",
-          "description" => route.swagger_meta[:description] || "",
-          "tags" => route.swagger_meta[:tags] || [extract_tag(route.path)],
+          "operationId" => unique_operation_id(method, path, ctx[:seen_ids]),
+          "summary" => meta[:summary] || "#{method.upcase} #{route.path}",
+          "description" => meta[:description] || "",
+          "tags" => tags,
           "parameters" => build_parameters(route),
-          "responses" => route.swagger_meta[:responses] || default_responses
+          "responses" => meta[:responses] || model_or_default_responses(ref, meta[:model_list])
         }
+        operation["deprecated"] = true if meta[:deprecated]
         if route.auth_handler
           operation["security"] = [{ "bearerAuth" => [] }]
         end
-        if %w[post put patch].include?(method) && route.swagger_meta[:request_body]
-          operation["requestBody"] = route.swagger_meta[:request_body]
-        elsif %w[post put patch].include?(method)
-          operation["requestBody"] = default_request_body
+        if %w[post put patch].include?(method)
+          operation["requestBody"] = build_request_body(method, meta, ref)
         end
         spec["paths"][path][method] = operation
       end
+      def build_request_body(_method, meta, ref)
+        return meta[:request_body] if meta[:request_body]
+        schema = ref ? { "$ref" => ref } : { "type" => "object" }
+        content = { "schema" => schema }
+        content["example"] = meta[:example] if meta[:example]
+        { "content" => { "application/json" => content } }
+      end
+      def model_or_default_responses(ref, model_list)
+        return default_responses unless ref
+        schema = model_list ? { "type" => "array", "items" => { "$ref" => ref } } : { "$ref" => ref }
+        {
+          "200" => {
+            "description" => "Successful response",
+            "content" => { "application/json" => { "schema" => schema } }
+          }
+        }
+      end
       def convert_path(path)
-        # Convert {id:int} to {id}
-        path.gsub(/\{(\w+)(?::\w+)?\}/, '{\1}')
+        # {id:int} -> {id}
+        p = path.gsub(/\{(\w+)(?::\w+)?\}/, '{\1}')
+        # splat *path -> {path}; bare /* -> /{wildcard} (a literal '*' segment
+        # or an orphaned splat param is invalid OpenAPI templating)
+        p = p.gsub(/\*(\w+)/, '{\1}')
+        p.gsub(%r{(?<=/)\*(?=/|$)}, "{wildcard}")
       end
       def extract_tag(path)
         parts = path.split("/").reject(&:empty?)
-        parts.first || "default"
+        first = parts.first
+        return "default" if first.nil? || first.start_with?("{", "*")
+        first
+      end
+      def unique_operation_id(method, path, seen)
+        base = method + path.gsub(%r{[/{}*]}) { |c| c == "*" ? "wildcard" : "_" }
+        base = base.gsub(/_+/, "_").chomp("_")
+        oid = base
+        n = 2
+        while seen.include?(oid)
+          oid = "#{base}_#{n}"
+          n += 1
+        end
+        seen << oid
+        oid
       end
       def build_parameters(route)
         params = []
         route.param_names.each do |param|
+          name = param[:name].to_s
+          name = "wildcard" if name == "*"
           params << {
-            "name" => param[:name].to_s,
+            "name" => name,
             "in" => "path",
             "required" => true,
             "schema" => param_schema(param[:type])
@@ -118,16 +207,71 @@ module Tina4
       end
       def param_schema(type)
-        case type
+        case type.to_s
         when "int", "integer"
           { "type" => "integer" }
         when "float", "number"
           { "type" => "number" }
+        when "uuid"
+          { "type" => "string", "format" => "uuid" }
+        when "slug"
+          { "type" => "string", "pattern" => "^[a-z0-9]+(?:-[a-z0-9]+)*$" }
+        when "alpha"
+          { "type" => "string", "pattern" => "^[A-Za-z]+$" }
+        when "alnum"
+          { "type" => "string", "pattern" => "^[A-Za-z0-9]+$" }
+        else
+          { "type" => "string" }
+        end
+      end
+      # Build a components.schemas object from an ORM model's field definitions.
+      def model_schema(model_class)
+        props = {}
+        required = []
+        defs = model_class.respond_to?(:field_definitions) ? model_class.field_definitions : {}
+        defs.each do |name, opts|
+          props[name.to_s] = field_schema(opts)
+          required << name.to_s if opts[:nullable] == false
+        end
+        schema = { "type" => "object", "properties" => props.empty? ? {} : props }
+        schema["required"] = required unless required.empty?
+        schema
+      end
+      def field_schema(opts)
+        schema = map_field_type(opts[:type])
+        schema["readOnly"] = true if opts[:primary_key] && opts[:auto_increment]
+        schema
+      end
+      def map_field_type(type)
+        case type.to_s
+        when "integer"
+          { "type" => "integer" }
+        when "float", "decimal", "numeric"
+          { "type" => "number" }
+        when "boolean"
+          { "type" => "boolean" }
+        when "datetime", "date", "timestamp"
+          { "type" => "string", "format" => "date-time" }
+        when "blob"
+          { "type" => "string", "format" => "byte" }
         else
           { "type" => "string" }
         end
       end
+      def resolve_model(name)
+        Object.const_get(name)
+      rescue NameError
+        begin
+          Tina4.const_get(name)
+        rescue NameError
+          nil
+        end
+      end
       def default_responses
         {
           "200" => { "description" => "Successful response" },
@@ -137,16 +281,6 @@ module Tina4
           "500" => { "description" => "Internal server error" }
         }
       end
-      def default_request_body
-        {
-          "content" => {
-            "application/json" => {
-              "schema" => { "type" => "object" }
-            }
-          }
-        }
-      end
     end
   end
 end

data/lib/tina4/version.rb CHANGED Viewed

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 module Tina4
-  VERSION = "3.13.39"
+  VERSION = "3.13.41"
 end

data/lib/tina4.rb CHANGED Viewed

@@ -50,6 +50,7 @@ require_relative "tina4/error_overlay"
 require_relative "tina4/test_client"
 require_relative "tina4/test"
 require_relative "tina4/docs"
+require_relative "tina4/docstore"
 require_relative "tina4/mcp"
 module Tina4

metadata CHANGED Viewed

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tina4ruby
 version: !ruby/object:Gem::Version
-  version: 3.13.39
+  version: 3.13.41
 platform: ruby
 authors:
 - Tina4 Team
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-06-21 00:00:00.000000000 Z
+date: 2026-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -278,6 +278,7 @@ files:
 - lib/tina4/dev_admin.rb
 - lib/tina4/dev_mailbox.rb
 - lib/tina4/docs.rb
+- lib/tina4/docstore.rb
 - lib/tina4/drivers/firebird_driver.rb
 - lib/tina4/drivers/mongodb_driver.rb
 - lib/tina4/drivers/mssql_driver.rb