ಆನ್ಲೈನ್ JSONರಿಂದ JSON ಸ್ಕೀಮಾ ಜನರೇಟರ್

ಸ್ಕೀಮಾ ರಚನೆ ಯಂತ್ರದ ಒಳನೋಟ

ಮಾದರಿ JSON ನಿಂದ JSON ಸ್ಕೀಮಾ ರಚಿಸುವುದು ಕೇವಲ ಕ್ಷೇತ್ರಗಳನ್ನು ಪ್ರಕಾರಗಳಿಗೆ ನಕ್ಷೆ ಮಾಡಲು ಮಾತ್ರವಲ್ಲ, ಇದು ಕೆಲವು ಮುಖ್ಯ ಹಂತಗಳನ್ನು ಒಳಗೊಂಡಿದೆ:

1. ಪಾರ್ಸಿಂಗ್: ಸಾಧನವು ನಿಮ್ಮ JSON ಅನ್ನು ECMA-404 ಪ್ರಕಾರ ಪಾರ್ಸ್ ಮಾಡುತ್ತದೆ, ತಪ್ಪು ಅಥವಾ ಸ್ಪಷ್ಟವಿಲ್ಲದ ಇನ್‌ಪುಟ್‌ಗಳಿಗೆ ವಿವರವಾದ ದೋಷಗಳನ್ನು ವರದಿಗೊಳಿಸುತ್ತದೆ.
2. ರಚನಾತ್ಮಕ ವಿಶ್ಲೇಷಣೆ: ಇದು ನಿಮ್ಮ ಡೇಟಾದ ಟ್ರೀ ಪ್ರತಿರೂಪವನ್ನು ನಿರ್ಮಿಸುತ್ತದೆ ಮತ್ತು ಎಲ್ಲ ಗುಣಲಕ್ಷಣಗಳನ್ನು JSON ಸ್ಕೀಮಾದ ಮೂಲ ಪ್ರಕಾರಗಳ (ಒಬ್ಬ್ಜಿ, ಅರೆ, ಸ್ಟ್ರಿಂಗ್, ಸಂಖ್ಯೆ, ಪೂರ್ಣಾಂಕ, ಬೂಲ್, ನಲ್) ಪ್ರಕಾರ ವರ್ಗೀಕರಿಸುತ್ತದೆ.
3. ಪುನರಾವರ್ತಿತ ಸಂಚರಣೆ: ಆಳವಾದ ಹಾಗೂ ನೆಸ್ಟೆಡ್ ರಚನೆಗಳು—ಒಯ್ಯವ ಪಾತ್ರೆಗಳ ಅರೆಗಳು ಅಥವಾ ನೆಸ್ಟೆಡ್ ಅರೆಗಳಾಗಲೀ—ಪುನರಾವರ್ತಿತವಾಗಿ ಸಂಚರಿಸಿ ನೆಸ್ಟೆಡ್ ಸ್ಕೀಮಾ ವಿವರಣೆಗಳನ್ನು ರಚಿಸಲಾಗುತ್ತದೆ.
4. ಪ್ರಕಾರ ಇನ್ಫರೆನ್ಸ್ ಮತ್ತು ಮರ್ಜಿಂಗ್: ಪ್ರತಿ ಗುಣಲಕ್ಷಣ ಅಥವಾ ಅರೆ ಅಂಶಕ್ಕೆ ಪ್ರಕಾರವನ್ನು ಇನ್ಫರೆ ಮಾಡಲಾಗುತ್ತದೆ. ಮಿಶ್ರಿತ ಪ್ರಕಾರಗಳಿದ್ದಲ್ಲಿ 'type' ಅನ್ನು JSON ಸ್ಕೀಮಾ ವಿಶೇಷಣಮಂತ್ರದಂತೆ ಸರಣಿಯಾಗಿ ('type' ಅರೆ) ವಿವರಿಸಲಾಗುತ್ತದೆ.
5. ಅವಶ್ಯಕ ಮತ್ತು ವೈಕಲ್ಯ ಪತ್ತೆ: ಪ್ರತಿಯೊಂದೂ ಮಟ್ಟದಲ್ಲಿನ ಬ объект ಗಳ ವಿಶ್ಲೇಷಣೆಯಿಂದ ಯಾವ ಗುಣಲಕ್ಷಣಗಳು ಸದಾ ನಿಯಮಿತವಾಗಿರುವವು (ಅವಶ್ಯಕ) ಮತ್ತು ಯಾವವು ಕೆಲವೊಮ್ಮೆ ಇಲ್ಲದಿರುವವು (ಐಚ್ಛಿಕ) ಎಂಬುದನ್ನು ಬೇರ್ಪಡಿಸುತ್ತದೆ.
6. ಮೌಲ್ಯ ನಿಯಮಗಳು: ಸಾಧ್ಯವಾದಂತೆ, enums (ಅನುವುಳ್ಳ ಮೌಲ್ಯಗಳ ಶ್ರೆಣಿಗಳು), ಸಂಖ್ಯೆಗಳಿಗೆ ಕನಿಷ್ಠ/ಗರಿಷ್ಠ, ಸ್ಟ್ರಿಂಗ್‌ಗಾಗಿ ಕನಿಷ್ಠ ಉದ್ದ/ಗರಿಷ್ಠ ಉದ್ದ, ಹಾಗೂ ಫಾರ್ಮಾಟ್ ಸೂಚನೆಗಳು ('email', 'uri', 'date-time' ಮುಂತಾದ) ಇನ್ಫರೆ ಮಾಡಲಾಗುತ್ತದೆ.
7. ಅತಿ ಸೂಕ್ಷ್ಮ ಪ್ರಕರಣಗಳ ನಿರ್ವಹಣೆ: ಖಾಲಿ ಅರೆಗಳು, ನಲ್ ಗಳನ್ನು ಮತ್ತು ಅಸ್ಪಷ್ಟ ರಚನೆಗಳನ್ನು ವಿಶೇಷ ಗಮನಕೊಟ್ಟು ಸಕಾಲಿಕ ನಿಖರ JSON ಸ್ಕೀಮಾಗಳು ರೂಪುಗೊಳ್ಳುತ್ತವೆ.
8. ಸ್ಕೀಮಾ ಸಂಕಲನ: ಅಂತಿಮ ಸ್ಕೀಮಾ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಅನುಗುಣ ಡ್ರಾಫ್ಟ್-07 ಡಾಕ್ಯುಮೆಂಟ್ ಆಗಿ ರಿಲೀಸ್ ಆಗುತ್ತದೆ—Ajv, OpenAPI, ಅಥವಾ ಕೋಡ್ ಜನರೇಷನ್ ಗ್ರಂಥಾಲಯಗಳೊಂದಿಗೆ ಬಳಸಲು ಸಿದ್ಧವಾಗಿದೆ.

ಯಾಕೆ JSON ಸ್ಕೀಮಾ ರಚಿಸಬೇಕು? ಪ್ರಾಯೋಗಿಕ ಉಪಯೋಗಗಳು

• ಸ್ವಯಂಚಾಲಿತ ಮಾನ್ಯತೆ: ರಚಿಸಲಾದ ಸ್ಕೀಮಾಗಳ ಮೂಲಕ ಡೇಟಾ ಒಪ್ಪಂದಗಳನ್ನು ಬಲವಂತಪಡಿಸಿ ಮತ್ತು ನಿಮ್ಮ APIಗಳ, ಮೈಕ್ರೋಸರ್ವೀಸ್‌ಗಳ ಅಥವಾ CLIಗಳ ಆಗಮನ ಪೇಲೋಡ್‌ಗಳನ್ನು ಮಾನ್ಯ ಮಾಡಿ.
• API ದಾಖಲೆ: ಖಚಿತ ಡೇಟಾ ವ್ಯಾಖ್ಯಾನಗಳೊಂದಿಗೆ ಸ್ವಯಂಚಾಲಿತ ಡಾಕ್ಯುಮೆಂಟ್ ಮತ್ತು ಇಂಟರಾಕ್ಟಿವ್ ಎಕ್ಸ್‌ಪ್ಲೋರರ್‌ಗಳ (Swagger, Postman) ಉತ್ಪಾದನೆ.
• ಕೋಡ್ ಜನರೇಷನ್: ನಿಮ್ಮ ಸ್ಕೀಮಾವನ್ನು ಏಕಮಾತ್ರ ಸತ್ಯ ಮೂಲವಾಗಿ ಬಳಸಿ, ಟೈಪ್-ಸೆಫ ಆಗಿರುವ ಮಾದರಿಗಳು ಅಥವಾ ಮಾನ್ಯಕರನ್ನು ಟೈಪ್ಸ್ಕ್ರಿಪ್ಟ್, ಪೈಥಾನ್, ಜावा ಮತ್ತು ಇತರ ಭಾಷೆಗಳಲ್ಲಿ ಸೃಷ್ಟಿಸಿ.
• ಟೆಸ್ಟ್ ಡೇಟಾ ಉತ್ಪಾದನೆ: JSON ಸ್ಕೀಮಾ ಫೇಕರ್ ಅಥವಾ ಮೊಕರೌ ಸಂತೋಷವನ್ನು ಬಳಸುವ ಸಾಧನಗಳು ಗುಣಮಟ್ಟ ಹಾಗೂ ಲೋಡ್ ಪರೀಕ್ಷೆಗೆ ನೈಜ ಮೋಕ್ ಡೇಟಾವನ್ನು ಸಿಂಥೆಸೈಸ್ ಮಾಡುತ್ತವೆ.
• ಪುನರ್‌ರಚನೆ ಮತ್ತು ವಲಸೆ: ಪುರಾತನ ಅಥವಾ ಬದಲಾಗುತ್ತಿರುವ ಡೇಟಾ ರಚನೆಗಳನ್ನು ಮಾನ್ಯ ಮಾಡಿ, ನಿಮ್ಮ ಬ್ಯಾಕ್ ಎಂಡ್ ಬೆಳವಣಿಗೆಯಂತೆ ಹೊಂದಾಣಿಕೆ ಖಾತ್ರಿಪಡಿಸಿ.

ತಾಂತ್ರಿಕ ವೈಶಿಷ್ಟ್ಯಗಳು

• ಡ್ರಾಫ್ಟ್-07 ಹೊಂದಿಕೊಳ್ಳುವಿಕೆಗೆ ಹೆಚ್ಚಿನ ಸ್ಪರ್ಧಣಾ ಸಾಮರ್ಥ್ಯದೊಂದಿಗೆ ಪ್ರಮುಖ ಮಾನ್ಯತೆಯನ್ನು ಹೊಂದಿರುವಪ್ಪುಗಳಿಗೆ ಮತ್ತು API ವಿನ್ಯಾಸ ವೇದಿಕೆಗಳಿಗೆ ಸಹಕಾರ.
• ಯಾವುದೇ ಆಳದ ನೆಸ್ಟಿಂಗ್ ವಿಶ್ಲೇಷಣೆ—ಅರೆಗಳಲ್ಲಿ ಅರೆಗಳು, ಅರೆಗಳಲ್ಲಿ ವ್ಯಕ್ತಿಗಳು, ಮತ್ತಷ್ಟು.
• ಬೇರೆ ಮಾದರಿಗಳಲ್ಲಿ ಬದಲಾಗುವ ಕ್ಷೇತ್ರಗಳು ಅಥವಾ ವಸ್ತುಗಳಿಗಾಗಿ ಸರಿಯಾದ ಸಂಯುಕ್ತ ಪ್ರಕಾರ ('type' ಅರೆ) ಇನ್ಫರೆನ್ಸ್.
• Enums, ಉದ್ದ, ರೂಪ, ಫಾರ್ಮಾಟ್, ಕನಿಷ್ಠ/ಗರಿಷ್ಠ, ಮತ್ತು ಇತರ ಸಾಮಾನ್ಯ ನಿಯಮಗಳ ಸ್ವಯಂಚಾಲಿತ ಪತ್ತೆ ಇತ್ಯಾದಿ.
• ನಲ್‌ಗಳು, ಖಾಲಿ ಅರೆಗಳು/ವಸ್ತುಗಳು ಮತ್ತು ಅಡ್ಡಸ್ಟ್ರಕ್ಚರ್‌ಗಳ ಸ್ಪಷ್ಟ ಬೆಂಬಲ.
• ಸ್ಕೀಮಾ ರಚನೆ ಸಂಪೂರ್ಣವಾಗಿ ಬ್ರೌಸರ್‌ನಲ್ಲಿ ನಡೆಯುತ್ತದೆ. ನಿಮ್ಮ ಇನ್‌ಪುಟ್ JSON ನಿಮ್ಮ ಸಾಧನವನ್ನು ಮುಚ್ಚಲಾಗುವುದಿಲ್ಲ.

ತಾಂತ್ರಿಕ ಉದಾಹರಣೆ: ಮಾದರಿ JSON ನಿಂದ ಡ್ರಾಫ್ಟ್-07 ಸ್ಕೀಮಾಗೆ

{
  "transaction": {
    "id": "txn_abc123",
    "amount": 99.95,
    "currency": "USD",
    "status": "completed",
    "meta": {
      "ip": "203.0.113.1",
      "tags": ["recurring", null]
    }
  },
  "refunded": false,
  "notes": null
}

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "transaction": {
      "type": "object",
      "properties": {
        "id": { "type": "string" },
        "amount": { "type": "number" },
        "currency": { "type": "string", "minLength": 3, "maxLength": 3 },
        "status": { "type": "string", "enum": ["completed"] },
        "meta": {
          "type": "object",
          "properties": {
            "ip": { "type": "string", "format": "ipv4" },
            "tags": {
              "type": "array",
              "items": { "type": ["string", "null"] }
            }
          },
          "required": ["ip", "tags"]
        }
      },
      "required": ["id", "amount", "currency", "status", "meta"]
    },
    "refunded": { "type": "boolean" },
    "notes": { "type": ["null"] }
  },
  "required": ["transaction", "refunded", "notes"]
}

ಈ JSON ರಿಂದ JSON ಸ್ಕೀಮಾ ಸಾಧನವನ್ನು ಹೇಗೆ ಬಳಸುವುದು

1. ನಿಮ್ಮ ಮಾದರಿ JSON ಅನ್ನು ಕೆಳಗಿನ ಸಂಪಾದಕದಲ್ಲಿ ಅಂಟಿಸಿ ಅಥವಾ ಟೈಪ್ ಮಾಡಿ. ಸಾಧನ ಯಾವುದೇ ಮಾನ್ಯ JSON ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ, ಸಾದಾರಣOccupation‍ದ ವಸ್ತುಗಳಿಂದ ಆಳವಾದ ನೆಸ್ಟೆಡ್ ರಚನೆಗಳ ತನಕ.
2. 'JSON ಸ್ಕೀಮಾ ರಚಿಸಿ' ಬಟನ್ ಕ್ಲಿಕ್ ಮಾಡಿ ಮತ್ತು ರಚಿಸಲಾದ JSON ಸ್ಕೀಮಾ ಅನ್ನು ವೀಕ್ಷಿಸಿ.
3. ಸ್ಕೀಮಾ ನಕಲಿಸಿ, ಸಂಪಾದಿಸಿ ಅಥವಾ ಡೌನ್‌ಲೋಡ್ ಮಾಡಿ. ಇದನ್ನು ನೇರವಾಗಿ ನಿಮ್ಮ API ವ್ಯಾಖ್ಯಾನಗಳು, ಮಾನ್ಯತೆ ಲಾಜಿಕ್ ಅಥವಾ ದಾಖಲೆಗಳಲ್ಲಿ ಸಂಯೋಜಿಸಿ.

JSON ನಿಂದ ಸ್ಕೀಮಾ ರಚನೆಗೆ ಕೋಡ್ ಉದಾಹರಣೆಗಳು

ವಿವಿಧ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ JSON ನಿಂದ JSON ಸ್ಕೆಮಾ ಅನ್ನು ಹೇಗೆ ರಚಿಸುವುದೆಂದು ನೋಡಿ.

const generateSchema = require('jsonschema-generator');
const data = {
  name: "Alice",
  age: 30,
  isActive: true,
  tags: ["user", "admin"]
};
const schema = generateSchema(data);
console.log(JSON.stringify(schema, null, 2));

const GenerateSchema = require('generate-schema');
const data = { name: "Alice", age: 30, tags: ["admin", "user"] };
const schema = GenerateSchema.json('User', data);
console.log(JSON.stringify(schema, null, 2));

from genson import SchemaBuilder
sample = {"name": "Alice", "age": 30, "tags": ["user", "admin"]}
builder = SchemaBuilder()
builder.add_object(sample)
print(builder.to_json(indent=2))

from jsonschema_generate import generate_schema
sample = {"name": "Alice", "age": 30, "tags": ["user", "admin"]}
schema = generate_schema(sample)
print(schema)

package main
import (
  "encoding/json"
  "fmt"
  "github.com/invopop/jsonschema"
)
type User struct {
  Name string   `json:"name"
  Age  int      `json:"age"
  Tags []string `json:"tags"
}
func main() {
  schema := jsonschema.Reflect(&User{})
  out, _ := json.MarshalIndent(schema, "", "  ")
  fmt.Println(string(out))
}

# Generate Java POJOs *from* a JSON Schema, not the reverse.
# For schema generation from Java, see tools like jackson-module-jsonSchema.
# See: https://github.com/FasterXML/jackson-module-jsonSchema

using NJsonSchema;
using Newtonsoft.Json.Linq;
var sample = JObject.Parse("{\"name\":\"Alice\",\"age\":30, \"tags\":[\"user\"]}");
var schema = await JsonSchema.FromSampleJsonAsync(sample.ToString());
Console.WriteLine(schema.ToJson());

require 'vendor/autoload.php';
use Swaggest\JsonSchema\Structure\ClassStructure;
$sample = ["name" => "Alice", "age" => 30, "tags" => ["user"]];
$schema = ClassStructure::exportSchema($sample);
echo json_encode($schema, JSON_PRETTY_PRINT);

require 'json_schemer'
sample = { "name" => "Alice", "age" => 30, "tags" => ["admin", "user"] }
schema = JSONSchemer.schema(sample)
puts schema.to_json

echo '{"name":"Alice","age":30,"tags":["user","admin"]}' | genson | jq .

use schemars::JsonSchema;
use serde::Serialize;
#[derive(Serialize, JsonSchema)]
struct User {
  name: String,
  age: u32,
  tags: Vec<String>,
}
fn main() {
  let schema = schemars::schema_for!(User);
  println!("{}", serde_json::to_string_pretty(&schema).unwrap());
}

import json.schema._
case class User(name: String, age: Int, tags: List[String])
val schema = Json.schema[User]
println(schema.asSpray.prettyPrint)

# Generate schema from a TypeScript interface:
typescript-json-schema tsconfig.json User --out schema.json
# See https://github.com/YousefED/typescript-json-schema

// Dart does not have an automatic JSON Schema generator yet.
// Manually define schema as a Dart Map or use online tools.