@lowdep/json-schema-gen 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rushabh Shah
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,145 @@
+# json-schema-gen
+
+![Zero dependencies](https://img.shields.io/badge/dependencies-0-brightgreen) ![Node](https://img.shields.io/badge/node-%3E%3D14-blue) ![License: MIT](https://img.shields.io/badge/license-MIT-green) ![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux-lightgrey)
+
+
+Generate JSON Schema (draft-07) from sample JSON data. Detects string formats (email, URI, UUID, date-time), merges schemas from multiple samples, and outputs a clean schema ready for validation. Zero dependencies.
+
+Like `quicktype` but needs no installation — and `genson` (Python) or online tools are overkill when you just need a schema.
+
+---
+
+## Install
+
+```bash
+npm install -g json-schema-gen
+```
+
+Or without installing:
+
+```bash
+npx json-schema-gen data.json
+```
+
+---
+
+## Example
+
+Given `user.json`:
+```json
+{
+  "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+  "name": "Alice Johnson",
+  "email": "alice@example.com",
+  "age": 32,
+  "active": true,
+  "createdAt": "2024-01-15T09:30:00Z",
+  "tags": ["admin", "user"],
+  "address": {
+    "street": "123 Main St",
+    "city": "Springfield",
+    "zip": "62701"
+  }
+}
+```
+
+Running `json-schema-gen user.json --required` outputs:
+
+```json
+{
+  "$schema": "https://json-schema.org/draft-07/schema",
+  "type": "object",
+  "properties": {
+    "id":        { "type": "string", "format": "uuid" },
+    "name":      { "type": "string" },
+    "email":     { "type": "string", "format": "email" },
+    "age":       { "type": "integer" },
+    "active":    { "type": "boolean" },
+    "createdAt": { "type": "string", "format": "date-time" },
+    "tags":      { "type": "array", "items": { "type": "string" } },
+    "address": {
+      "type": "object",
+      "properties": {
+        "street": { "type": "string" },
+        "city":   { "type": "string" },
+        "zip":    { "type": "string" }
+      },
+      "required": ["street", "city", "zip"],
+      "additionalProperties": false
+    }
+  },
+  "required": ["id", "name", "email", "age", "active", "createdAt", "tags", "address"],
+  "additionalProperties": false
+}
+```
+
+---
+
+## Usage
+
+```bash
+json-schema-gen user.json                            # Basic schema
+json-schema-gen user.json --required                 # Mark all fields as required
+json-schema-gen user.json --title "User" --id "/schemas/user"
+json-schema-gen user.json --out schema.json          # Write to file
+json-schema-gen s1.json s2.json s3.json              # Merge from multiple samples
+cat data.json | json-schema-gen -                    # Read from stdin
+```
+
+---
+
+## Detected Formats
+
+| Format | Example |
+|---|---|
+| `date-time` | `"2024-01-15T09:30:00Z"` |
+| `date` | `"2024-01-15"` |
+| `time` | `"09:30:00"` |
+| `email` | `"user@example.com"` |
+| `uri` | `"https://example.com"` |
+| `uuid` | `"a1b2c3d4-e5f6-7890-abcd-ef1234567890"` |
+| `ipv4` | `"192.168.1.1"` |
+
+---
+
+## Multi-Sample Merging
+
+Pass multiple JSON files to infer a schema that covers all of them. Fields present in only some samples will not be marked `required`:
+
+```bash
+json-schema-gen user1.json user2.json user3.json
+```
+
+---
+
+## Options
+
+| Flag | Description |
+|---|---|
+| `--required` | Mark all non-null fields as required |
+| `--examples` | Include example values for string fields |
+| `--title <name>` | Add `title` to the schema |
+| `--id <uri>` | Add `$id` to the schema |
+| `--out <file>` | Write output to a file |
+
+---
+
+## License
+
+MIT
+
+---
+
+## Keywords
+
+`json schema generator` · `json to schema` · `quicktype alternative` · `genson alternative` · `infer schema` · `draft-07` · `generate schema` · `json schema` · `zero dependencies` · `cli`
+
+---
+
+<div align="center">
+
+**Built to solve, shared to help — Rushabh Shah 🛠️✨**
+
+<sub>One of 40+ zero-dependency developer CLI tools — no <code>node_modules</code>, ever.</sub>
+
+</div>

package/bin/json-schema-gen.js

@@ -0,0 +1,268 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const VERSION = '1.0.0';
+
+// ─── ANSI ─────────────────────────────────────────────────────────────────────
+const isTTY  = process.stdout.isTTY;
+const c      = (code, t) => isTTY ? `\x1b[${code}m${t}\x1b[0m` : t;
+const bold   = t => c('1',  t);
+const dim    = t => c('2',  t);
+const red    = t => c('31', t);
+const green  = t => c('32', t);
+const cyan   = t => c('36', t);
+const yellow = t => c('33', t);
+
+// ─── Format detectors ─────────────────────────────────────────────────────────
+const FORMAT_DETECTORS = [
+  { format: 'date-time', test: v => /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/.test(v) },
+  { format: 'date',      test: v => /^\d{4}-\d{2}-\d{2}$/.test(v) },
+  { format: 'time',      test: v => /^\d{2}:\d{2}(:\d{2})?$/.test(v) },
+  { format: 'email',     test: v => /^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(v) },
+  { format: 'uri',       test: v => /^https?:\/\//.test(v) },
+  { format: 'uuid',      test: v => /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(v) },
+  { format: 'ipv4',      test: v => /^(\d{1,3}\.){3}\d{1,3}$/.test(v) },
+];
+
+function detectFormat(s) {
+  for (const { format, test } of FORMAT_DETECTORS) {
+    if (test(s)) return format;
+  }
+  return null;
+}
+
+// ─── Schema inference ─────────────────────────────────────────────────────────
+function inferSchema(value, opts = {}) {
+  const { allRequired = false, examples = false } = opts;
+
+  if (value === null) return { type: 'null' };
+
+  if (typeof value === 'boolean') return { type: 'boolean' };
+
+  if (typeof value === 'number') {
+    return Number.isInteger(value) ? { type: 'integer' } : { type: 'number' };
+  }
+
+  if (typeof value === 'string') {
+    const schema = { type: 'string' };
+    if (value.length > 0) {
+      const fmt = detectFormat(value);
+      if (fmt) schema.format = fmt;
+      if (examples && !fmt) schema.examples = [value];
+    }
+    return schema;
+  }
+
+  if (Array.isArray(value)) {
+    if (value.length === 0) return { type: 'array', items: {} };
+    // Merge schemas of all items
+    const itemSchemas = value.map(v => inferSchema(v, opts));
+    const merged = mergeSchemas(itemSchemas);
+    return { type: 'array', items: merged };
+  }
+
+  if (typeof value === 'object') {
+    const properties = {};
+    const required   = [];
+
+    for (const [key, val] of Object.entries(value)) {
+      properties[key] = inferSchema(val, opts);
+      if (allRequired && val !== null && val !== undefined) {
+        required.push(key);
+      }
+    }
+
+    const schema = {
+      type: 'object',
+      properties,
+      additionalProperties: false,
+    };
+    if (required.length > 0) schema.required = required;
+    return schema;
+  }
+
+  return {};
+}
+
+// ─── Merge multiple schemas (for array items from multiple samples) ───────────
+function mergeSchemas(schemas) {
+  if (schemas.length === 0) return {};
+  if (schemas.length === 1) return schemas[0];
+
+  // Check if all the same type
+  const types = [...new Set(schemas.map(s => s.type))];
+  if (types.length > 1) {
+    // Multiple types — use anyOf
+    const uniqueSchemas = deduplicateSchemas(schemas);
+    if (uniqueSchemas.length === 1) return uniqueSchemas[0];
+    return { anyOf: uniqueSchemas };
+  }
+
+  const type = types[0];
+
+  if (type === 'object') {
+    // Merge object schemas: union all keys, mark keys missing in some as non-required
+    const allKeys = new Set(schemas.flatMap(s => Object.keys(s.properties || {})));
+    const properties = {};
+    const alwaysPresent = new Set([...allKeys]);
+
+    for (const key of allKeys) {
+      const keySchemas = schemas.filter(s => s.properties && key in s.properties).map(s => s.properties[key]);
+      if (keySchemas.length < schemas.length) alwaysPresent.delete(key);
+      properties[key] = mergeSchemas(keySchemas.length > 0 ? keySchemas : [{}]);
+    }
+
+    const merged = { type: 'object', properties, additionalProperties: false };
+    if (alwaysPresent.size > 0) merged.required = [...alwaysPresent];
+    return merged;
+  }
+
+  if (type === 'array') {
+    const itemSchemas = schemas.map(s => s.items).filter(Boolean);
+    return { type: 'array', items: itemSchemas.length > 0 ? mergeSchemas(itemSchemas) : {} };
+  }
+
+  // Primitive: just return first (they're all the same type)
+  const first = schemas[0];
+  // If formats differ, drop the format
+  const formats = [...new Set(schemas.map(s => s.format).filter(Boolean))];
+  if (formats.length === 1) return first;
+  const { format, ...rest } = first;
+  return rest;
+}
+
+function deduplicateSchemas(schemas) {
+  const seen = new Set();
+  return schemas.filter(s => {
+    const key = JSON.stringify(s);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+// ─── Merge schemas from multiple sample files ─────────────────────────────────
+function mergeFromSamples(samples, opts) {
+  const schemas = samples.map(v => inferSchema(v, opts));
+  return mergeSchemas(schemas);
+}
+
+// ─── CLI ──────────────────────────────────────────────────────────────────────
+const args = process.argv.slice(2);
+
+// Flags that consume the next argument as their value
+const VALUE_FLAGS = new Set(['--id', '--title', '--out']);
+
+function getFlag(f) {
+  const i = args.indexOf(f);
+  return i !== -1 ? args[i + 1] : null;
+}
+function hasFlag(f) { return args.includes(f); }
+
+// Positional args: skip flags and their values
+const positional = [];
+for (let i = 0; i < args.length; i++) {
+  if (args[i].startsWith('-')) {
+    if (VALUE_FLAGS.has(args[i])) i++; // skip the next value too
+  } else {
+    positional.push(args[i]);
+  }
+}
+
+if (hasFlag('--version') || hasFlag('-v')) {
+  console.log(`json-schema-gen v${VERSION}`); process.exit(0);
+}
+
+if (hasFlag('--help') || hasFlag('-h') || !positional.length) {
+  console.log(`
+${bold('json-schema-gen')} — Generate JSON Schema from sample JSON, zero dependencies
+
+${bold('USAGE')}
+  json-schema-gen <file.json> [file2.json ...] [options]
+
+${bold('OPTIONS')}
+  --required          Mark all non-null fields as required
+  --examples          Include example values for string fields
+  --id <uri>          Add $id to the schema
+  --title <name>      Add title to the schema
+  --out <file>        Write schema to file instead of stdout
+  --pretty            Pretty-print even when piped (default: always pretty)
+  --version           Show version
+
+${bold('EXAMPLES')}
+  json-schema-gen user.json
+  json-schema-gen user.json --required --title "User"
+  json-schema-gen sample1.json sample2.json   # Merge multiple samples
+  json-schema-gen data.json --out schema.json
+  cat data.json | json-schema-gen -            # Read from stdin
+`);
+  process.exit(positional.length ? 0 : 1);
+}
+
+const allRequired  = hasFlag('--required');
+const showExamples = hasFlag('--examples');
+const schemaId     = getFlag('--id');
+const schemaTitle  = getFlag('--title');
+const outFile      = getFlag('--out');
+
+const opts = { allRequired, examples: showExamples };
+
+// Read all input files
+const samples = [];
+for (const p of positional) {
+  let raw;
+  if (p === '-') {
+    raw = fs.readFileSync('/dev/stdin', 'utf8');
+  } else {
+    const fullPath = path.resolve(p);
+    if (!fs.existsSync(fullPath)) {
+      console.error(red(`\nFile not found: ${fullPath}\n`)); process.exit(1);
+    }
+    raw = fs.readFileSync(fullPath, 'utf8');
+  }
+  try {
+    samples.push(JSON.parse(raw));
+  } catch (e) {
+    console.error(red(`\nInvalid JSON in ${p}: ${e.message}\n`)); process.exit(1);
+  }
+}
+
+// Generate schema
+const schema = samples.length === 1
+  ? inferSchema(samples[0], opts)
+  : mergeFromSamples(samples, opts);
+
+// Add meta fields
+const output = {
+  $schema: 'https://json-schema.org/draft-07/schema',
+  ...(schemaId    ? { $id: schemaId }       : {}),
+  ...(schemaTitle ? { title: schemaTitle }  : {}),
+  ...schema,
+};
+
+const jsonStr = JSON.stringify(output, null, 2);
+
+if (outFile) {
+  fs.writeFileSync(path.resolve(outFile), jsonStr + '\n');
+  const props = countProperties(output);
+  if (!isTTY || outFile) {
+    process.stderr.write(`\n${bold('json-schema-gen')}  ${dim(outFile)}\n`);
+    process.stderr.write(dim(`  ${props} propert${props === 1 ? 'y' : 'ies'} · ${positional.length} sample${positional.length > 1 ? 's' : ''}\n\n`));
+  }
+} else {
+  console.log(jsonStr);
+}
+
+function countProperties(schema, depth = 0) {
+  if (!schema || typeof schema !== 'object') return 0;
+  if (schema.type === 'object' && schema.properties) {
+    return Object.keys(schema.properties).reduce((sum, k) => sum + 1 + countProperties(schema.properties[k], depth + 1), 0);
+  }
+  if (schema.type === 'array' && schema.items) {
+    return countProperties(schema.items, depth);
+  }
+  return 0;
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@lowdep/json-schema-gen",
+  "version": "1.0.0",
+  "description": "Generate JSON Schema (draft-07) from sample JSON data — format detection, multi-sample merging, zero dependencies",
+  "bin": {
+    "json-schema-gen": "bin/json-schema-gen.js"
+  },
+  "keywords": [
+    "json",
+    "json-schema",
+    "schema",
+    "generator",
+    "cli",
+    "validation",
+    "zero-dependencies",
+    "json schema generator",
+    "json to schema",
+    "quicktype alternative",
+    "genson alternative",
+    "infer schema",
+    "draft-07",
+    "generate schema",
+    "json schema",
+    "zero dependencies"
+  ],
+  "author": "Rushabh Shah",
+  "license": "MIT",
+  "engines": {
+    "node": ">=14"
+  },
+  "files": [
+    "bin/"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Rushabh5000/json-schema-gen.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Rushabh5000/json-schema-gen/issues"
+  },
+  "homepage": "https://github.com/Rushabh5000/json-schema-gen#readme",
+  "publishConfig": {
+    "access": "public"
+  }
+}