@aarunyaapps/json-to-types 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,33 @@
+type PrimitiveKind = "string" | "number" | "boolean" | "null" | "unknown";
+type TypeRef = {
+    kind: "primitive";
+    type: PrimitiveKind;
+} | {
+    kind: "array";
+    elementType: TypeRef;
+} | {
+    kind: "ref";
+    name: string;
+};
+interface FieldDef {
+    key: string;
+    type: TypeRef;
+    nullable: boolean;
+}
+interface TypeDef {
+    name: string;
+    fields: FieldDef[];
+}
+interface ParseResult {
+    defs: TypeDef[];
+    rootRef: TypeRef;
+}
+declare function parseJson(json: unknown, rootName?: string): ParseResult;
+declare function generateTypeScript(result: ParseResult, rootName: string): string;
+declare function generateZod(result: ParseResult, rootName: string): string;
+declare function generateJsonSchema(result: ParseResult, rootName: string): string;
+declare function generateOpenApi(result: ParseResult, rootName: string): string;
+declare function generateYup(result: ParseResult, rootName: string): string;
+declare function generateValibot(result: ParseResult, rootName: string): string;
+
+export { type FieldDef, type ParseResult, type PrimitiveKind, type TypeDef, type TypeRef, generateJsonSchema, generateOpenApi, generateTypeScript, generateValibot, generateYup, generateZod, parseJson };

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+type PrimitiveKind = "string" | "number" | "boolean" | "null" | "unknown";
+type TypeRef = {
+    kind: "primitive";
+    type: PrimitiveKind;
+} | {
+    kind: "array";
+    elementType: TypeRef;
+} | {
+    kind: "ref";
+    name: string;
+};
+interface FieldDef {
+    key: string;
+    type: TypeRef;
+    nullable: boolean;
+}
+interface TypeDef {
+    name: string;
+    fields: FieldDef[];
+}
+interface ParseResult {
+    defs: TypeDef[];
+    rootRef: TypeRef;
+}
+declare function parseJson(json: unknown, rootName?: string): ParseResult;
+declare function generateTypeScript(result: ParseResult, rootName: string): string;
+declare function generateZod(result: ParseResult, rootName: string): string;
+declare function generateJsonSchema(result: ParseResult, rootName: string): string;
+declare function generateOpenApi(result: ParseResult, rootName: string): string;
+declare function generateYup(result: ParseResult, rootName: string): string;
+declare function generateValibot(result: ParseResult, rootName: string): string;
+
+export { type FieldDef, type ParseResult, type PrimitiveKind, type TypeDef, type TypeRef, generateJsonSchema, generateOpenApi, generateTypeScript, generateValibot, generateYup, generateZod, parseJson };

package/dist/index.js

@@ -0,0 +1,243 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  generateJsonSchema: () => generateJsonSchema,
+  generateOpenApi: () => generateOpenApi,
+  generateTypeScript: () => generateTypeScript,
+  generateValibot: () => generateValibot,
+  generateYup: () => generateYup,
+  generateZod: () => generateZod,
+  parseJson: () => parseJson
+});
+module.exports = __toCommonJS(index_exports);
+function toPascalCase(str) {
+  if (!str) return "Unknown";
+  return str.split(/[_\-\s.[\]]+/).filter(Boolean).map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
+}
+function inferRef(value, hint, defs, seen) {
+  if (value === null || value === void 0) return { kind: "primitive", type: "null" };
+  if (typeof value === "boolean") return { kind: "primitive", type: "boolean" };
+  if (typeof value === "number") return { kind: "primitive", type: "number" };
+  if (typeof value === "string") return { kind: "primitive", type: "string" };
+  if (Array.isArray(value)) {
+    if (value.length === 0) return { kind: "array", elementType: { kind: "primitive", type: "unknown" } };
+    return { kind: "array", elementType: inferRef(value[0], hint + "Item", defs, seen) };
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    let name = toPascalCase(hint);
+    let n = 2;
+    while (seen.has(name)) name = toPascalCase(hint) + String(n++);
+    seen.add(name);
+    const fields = Object.entries(obj).map(([k, v]) => ({
+      key: k,
+      type: inferRef(v, k, defs, seen),
+      nullable: v === null
+    }));
+    defs.push({ name, fields });
+    return { kind: "ref", name };
+  }
+  return { kind: "primitive", type: "unknown" };
+}
+function parseJson(json, rootName = "Root") {
+  const defs = [];
+  const seen = /* @__PURE__ */ new Set();
+  const rootRef = inferRef(json, rootName, defs, seen);
+  return { defs, rootRef };
+}
+function refToTs(ref) {
+  if (ref.kind === "primitive") return ref.type === "null" ? "null" : ref.type;
+  if (ref.kind === "array") {
+    const i = refToTs(ref.elementType);
+    return i.includes("|") ? `(${i})[]` : `${i}[]`;
+  }
+  return ref.name;
+}
+function generateTypeScript(result, rootName) {
+  const { defs, rootRef } = result;
+  const parts = [];
+  if (rootRef.kind !== "ref" && defs.length === 0) return `export type ${rootName} = ${refToTs(rootRef)};`;
+  if (rootRef.kind === "array") parts.push(`export type ${rootName} = ${refToTs(rootRef)};`);
+  for (const { name, fields } of defs) {
+    const lines = fields.map(({ key, type, nullable }) => {
+      const t = nullable ? `${refToTs(type)} | null` : refToTs(type);
+      const k = /[^a-zA-Z0-9_$]/.test(key) ? `"${key}"` : key;
+      return `  ${k}: ${t};`;
+    });
+    parts.push(`export interface ${name} {
+${lines.join("\n")}
+}`);
+  }
+  return parts.join("\n\n");
+}
+function refToZod(ref) {
+  if (ref.kind === "primitive") {
+    const m = { string: "z.string()", number: "z.number()", boolean: "z.boolean()", null: "z.null()", unknown: "z.unknown()" };
+    return m[ref.type];
+  }
+  if (ref.kind === "array") return `z.array(${refToZod(ref.elementType)})`;
+  return `${ref.name}Schema`;
+}
+function generateZod(result, rootName) {
+  const { defs, rootRef } = result;
+  if (defs.length === 0) return `import { z } from "zod";
+
+export const ${rootName}Schema = ${refToZod(rootRef)};`;
+  const schemas = defs.map(({ name, fields }) => {
+    const lines = fields.map(({ key, type, nullable }) => {
+      const t = nullable ? `${refToZod(type)}.nullable()` : refToZod(type);
+      const k = /[^a-zA-Z0-9_$]/.test(key) ? `"${key}"` : key;
+      return `  ${k}: ${t},`;
+    });
+    return `export const ${name}Schema = z.object({
+${lines.join("\n")}
+});`;
+  });
+  const rootAlias = rootRef.kind === "array" ? `
+export const ${rootName}Schema = z.array(${refToZod(rootRef.elementType)});` : "";
+  return `import { z } from "zod";
+
+${schemas.join("\n\n")}${rootAlias}`;
+}
+function refToJsonSchema(ref) {
+  if (ref.kind === "primitive") {
+    if (ref.type === "null") return { type: "null" };
+    if (ref.type === "unknown") return {};
+    return { type: ref.type };
+  }
+  if (ref.kind === "array") return { type: "array", items: refToJsonSchema(ref.elementType) };
+  return { "$ref": `#/definitions/${ref.name}` };
+}
+function generateJsonSchema(result, rootName) {
+  const { defs, rootRef } = result;
+  const definitions = {};
+  for (const { name, fields } of defs) {
+    const properties = {};
+    const required = [];
+    for (const { key, type, nullable } of fields) {
+      properties[key] = nullable ? { anyOf: [refToJsonSchema(type), { type: "null" }] } : refToJsonSchema(type);
+      if (!nullable) required.push(key);
+    }
+    definitions[name] = { type: "object", properties, ...required.length > 0 ? { required } : {}, additionalProperties: false };
+  }
+  const root = {
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    title: rootName,
+    ...rootRef.kind === "ref" ? { "$ref": `#/definitions/${rootRef.name}` } : rootRef.kind === "array" ? { type: "array", items: refToJsonSchema(rootRef.elementType) } : refToJsonSchema(rootRef),
+    ...Object.keys(definitions).length > 0 ? { definitions } : {}
+  };
+  return JSON.stringify(root, null, 2);
+}
+function refToOas(ref) {
+  if (ref.kind === "primitive") {
+    if (ref.type === "null") return { nullable: true };
+    if (ref.type === "unknown") return {};
+    return { type: ref.type };
+  }
+  if (ref.kind === "array") return { type: "array", items: refToOas(ref.elementType) };
+  return { "$ref": `#/components/schemas/${ref.name}` };
+}
+function generateOpenApi(result, rootName) {
+  const { defs, rootRef } = result;
+  const schemas = {};
+  for (const { name, fields } of defs) {
+    const properties = {};
+    const required = [];
+    for (const { key, type, nullable } of fields) {
+      properties[key] = nullable ? { ...refToOas(type), nullable: true } : refToOas(type);
+      if (!nullable) required.push(key);
+    }
+    schemas[name] = { type: "object", properties, ...required.length > 0 ? { required } : {} };
+  }
+  if (rootRef.kind !== "ref") {
+    schemas[rootName] = rootRef.kind === "array" ? { type: "array", items: refToOas(rootRef.elementType) } : refToOas(rootRef);
+  }
+  return JSON.stringify({ openapi: "3.0.3", info: { title: `${rootName} API`, version: "1.0.0" }, paths: {}, components: { schemas } }, null, 2);
+}
+function refToYup(ref) {
+  if (ref.kind === "primitive") {
+    const m = { string: "yup.string()", number: "yup.number()", boolean: "yup.boolean()", null: "yup.mixed().nullable()", unknown: "yup.mixed()" };
+    return m[ref.type];
+  }
+  if (ref.kind === "array") return `yup.array().of(${refToYup(ref.elementType)})`;
+  return `${ref.name}Schema`;
+}
+function generateYup(result, rootName) {
+  const { defs, rootRef } = result;
+  if (defs.length === 0) return `import * as yup from "yup";
+
+export const ${rootName}Schema = ${refToYup(rootRef)};`;
+  const schemas = defs.map(({ name, fields }) => {
+    const lines = fields.map(({ key, type, nullable }) => {
+      const t = nullable ? `${refToYup(type)}.nullable()` : refToYup(type);
+      const k = /[^a-zA-Z0-9_$]/.test(key) ? `"${key}"` : key;
+      return `  ${k}: ${t},`;
+    });
+    return `export const ${name}Schema = yup.object({
+${lines.join("\n")}
+}).required();`;
+  });
+  const rootAlias = rootRef.kind === "array" ? `
+export const ${rootName}Schema = yup.array().of(${refToYup(rootRef.elementType)}).required();` : "";
+  return `import * as yup from "yup";
+
+${schemas.join("\n\n")}${rootAlias}`;
+}
+function refToValibot(ref) {
+  if (ref.kind === "primitive") {
+    const m = { string: "v.string()", number: "v.number()", boolean: "v.boolean()", null: "v.null_()", unknown: "v.unknown()" };
+    return m[ref.type];
+  }
+  if (ref.kind === "array") return `v.array(${refToValibot(ref.elementType)})`;
+  return `${ref.name}Schema`;
+}
+function generateValibot(result, rootName) {
+  const { defs, rootRef } = result;
+  if (defs.length === 0) return `import * as v from "valibot";
+
+export const ${rootName}Schema = ${refToValibot(rootRef)};`;
+  const schemas = defs.map(({ name, fields }) => {
+    const lines = fields.map(({ key, type, nullable }) => {
+      const t = nullable ? `v.nullable(${refToValibot(type)})` : refToValibot(type);
+      const k = /[^a-zA-Z0-9_$]/.test(key) ? `"${key}"` : key;
+      return `  ${k}: ${t},`;
+    });
+    return `export const ${name}Schema = v.object({
+${lines.join("\n")}
+});`;
+  });
+  const rootAlias = rootRef.kind === "array" ? `
+export const ${rootName}Schema = v.array(${refToValibot(rootRef.elementType)});` : "";
+  return `import * as v from "valibot";
+
+${schemas.join("\n\n")}${rootAlias}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateJsonSchema,
+  generateOpenApi,
+  generateTypeScript,
+  generateValibot,
+  generateYup,
+  generateZod,
+  parseJson
+});

package/dist/index.mjs

@@ -0,0 +1,212 @@
+// src/index.ts
+function toPascalCase(str) {
+  if (!str) return "Unknown";
+  return str.split(/[_\-\s.[\]]+/).filter(Boolean).map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
+}
+function inferRef(value, hint, defs, seen) {
+  if (value === null || value === void 0) return { kind: "primitive", type: "null" };
+  if (typeof value === "boolean") return { kind: "primitive", type: "boolean" };
+  if (typeof value === "number") return { kind: "primitive", type: "number" };
+  if (typeof value === "string") return { kind: "primitive", type: "string" };
+  if (Array.isArray(value)) {
+    if (value.length === 0) return { kind: "array", elementType: { kind: "primitive", type: "unknown" } };
+    return { kind: "array", elementType: inferRef(value[0], hint + "Item", defs, seen) };
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    let name = toPascalCase(hint);
+    let n = 2;
+    while (seen.has(name)) name = toPascalCase(hint) + String(n++);
+    seen.add(name);
+    const fields = Object.entries(obj).map(([k, v]) => ({
+      key: k,
+      type: inferRef(v, k, defs, seen),
+      nullable: v === null
+    }));
+    defs.push({ name, fields });
+    return { kind: "ref", name };
+  }
+  return { kind: "primitive", type: "unknown" };
+}
+function parseJson(json, rootName = "Root") {
+  const defs = [];
+  const seen = /* @__PURE__ */ new Set();
+  const rootRef = inferRef(json, rootName, defs, seen);
+  return { defs, rootRef };
+}
+function refToTs(ref) {
+  if (ref.kind === "primitive") return ref.type === "null" ? "null" : ref.type;
+  if (ref.kind === "array") {
+    const i = refToTs(ref.elementType);
+    return i.includes("|") ? `(${i})[]` : `${i}[]`;
+  }
+  return ref.name;
+}
+function generateTypeScript(result, rootName) {
+  const { defs, rootRef } = result;
+  const parts = [];
+  if (rootRef.kind !== "ref" && defs.length === 0) return `export type ${rootName} = ${refToTs(rootRef)};`;
+  if (rootRef.kind === "array") parts.push(`export type ${rootName} = ${refToTs(rootRef)};`);
+  for (const { name, fields } of defs) {
+    const lines = fields.map(({ key, type, nullable }) => {
+      const t = nullable ? `${refToTs(type)} | null` : refToTs(type);
+      const k = /[^a-zA-Z0-9_$]/.test(key) ? `"${key}"` : key;
+      return `  ${k}: ${t};`;
+    });
+    parts.push(`export interface ${name} {
+${lines.join("\n")}
+}`);
+  }
+  return parts.join("\n\n");
+}
+function refToZod(ref) {
+  if (ref.kind === "primitive") {
+    const m = { string: "z.string()", number: "z.number()", boolean: "z.boolean()", null: "z.null()", unknown: "z.unknown()" };
+    return m[ref.type];
+  }
+  if (ref.kind === "array") return `z.array(${refToZod(ref.elementType)})`;
+  return `${ref.name}Schema`;
+}
+function generateZod(result, rootName) {
+  const { defs, rootRef } = result;
+  if (defs.length === 0) return `import { z } from "zod";
+
+export const ${rootName}Schema = ${refToZod(rootRef)};`;
+  const schemas = defs.map(({ name, fields }) => {
+    const lines = fields.map(({ key, type, nullable }) => {
+      const t = nullable ? `${refToZod(type)}.nullable()` : refToZod(type);
+      const k = /[^a-zA-Z0-9_$]/.test(key) ? `"${key}"` : key;
+      return `  ${k}: ${t},`;
+    });
+    return `export const ${name}Schema = z.object({
+${lines.join("\n")}
+});`;
+  });
+  const rootAlias = rootRef.kind === "array" ? `
+export const ${rootName}Schema = z.array(${refToZod(rootRef.elementType)});` : "";
+  return `import { z } from "zod";
+
+${schemas.join("\n\n")}${rootAlias}`;
+}
+function refToJsonSchema(ref) {
+  if (ref.kind === "primitive") {
+    if (ref.type === "null") return { type: "null" };
+    if (ref.type === "unknown") return {};
+    return { type: ref.type };
+  }
+  if (ref.kind === "array") return { type: "array", items: refToJsonSchema(ref.elementType) };
+  return { "$ref": `#/definitions/${ref.name}` };
+}
+function generateJsonSchema(result, rootName) {
+  const { defs, rootRef } = result;
+  const definitions = {};
+  for (const { name, fields } of defs) {
+    const properties = {};
+    const required = [];
+    for (const { key, type, nullable } of fields) {
+      properties[key] = nullable ? { anyOf: [refToJsonSchema(type), { type: "null" }] } : refToJsonSchema(type);
+      if (!nullable) required.push(key);
+    }
+    definitions[name] = { type: "object", properties, ...required.length > 0 ? { required } : {}, additionalProperties: false };
+  }
+  const root = {
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    title: rootName,
+    ...rootRef.kind === "ref" ? { "$ref": `#/definitions/${rootRef.name}` } : rootRef.kind === "array" ? { type: "array", items: refToJsonSchema(rootRef.elementType) } : refToJsonSchema(rootRef),
+    ...Object.keys(definitions).length > 0 ? { definitions } : {}
+  };
+  return JSON.stringify(root, null, 2);
+}
+function refToOas(ref) {
+  if (ref.kind === "primitive") {
+    if (ref.type === "null") return { nullable: true };
+    if (ref.type === "unknown") return {};
+    return { type: ref.type };
+  }
+  if (ref.kind === "array") return { type: "array", items: refToOas(ref.elementType) };
+  return { "$ref": `#/components/schemas/${ref.name}` };
+}
+function generateOpenApi(result, rootName) {
+  const { defs, rootRef } = result;
+  const schemas = {};
+  for (const { name, fields } of defs) {
+    const properties = {};
+    const required = [];
+    for (const { key, type, nullable } of fields) {
+      properties[key] = nullable ? { ...refToOas(type), nullable: true } : refToOas(type);
+      if (!nullable) required.push(key);
+    }
+    schemas[name] = { type: "object", properties, ...required.length > 0 ? { required } : {} };
+  }
+  if (rootRef.kind !== "ref") {
+    schemas[rootName] = rootRef.kind === "array" ? { type: "array", items: refToOas(rootRef.elementType) } : refToOas(rootRef);
+  }
+  return JSON.stringify({ openapi: "3.0.3", info: { title: `${rootName} API`, version: "1.0.0" }, paths: {}, components: { schemas } }, null, 2);
+}
+function refToYup(ref) {
+  if (ref.kind === "primitive") {
+    const m = { string: "yup.string()", number: "yup.number()", boolean: "yup.boolean()", null: "yup.mixed().nullable()", unknown: "yup.mixed()" };
+    return m[ref.type];
+  }
+  if (ref.kind === "array") return `yup.array().of(${refToYup(ref.elementType)})`;
+  return `${ref.name}Schema`;
+}
+function generateYup(result, rootName) {
+  const { defs, rootRef } = result;
+  if (defs.length === 0) return `import * as yup from "yup";
+
+export const ${rootName}Schema = ${refToYup(rootRef)};`;
+  const schemas = defs.map(({ name, fields }) => {
+    const lines = fields.map(({ key, type, nullable }) => {
+      const t = nullable ? `${refToYup(type)}.nullable()` : refToYup(type);
+      const k = /[^a-zA-Z0-9_$]/.test(key) ? `"${key}"` : key;
+      return `  ${k}: ${t},`;
+    });
+    return `export const ${name}Schema = yup.object({
+${lines.join("\n")}
+}).required();`;
+  });
+  const rootAlias = rootRef.kind === "array" ? `
+export const ${rootName}Schema = yup.array().of(${refToYup(rootRef.elementType)}).required();` : "";
+  return `import * as yup from "yup";
+
+${schemas.join("\n\n")}${rootAlias}`;
+}
+function refToValibot(ref) {
+  if (ref.kind === "primitive") {
+    const m = { string: "v.string()", number: "v.number()", boolean: "v.boolean()", null: "v.null_()", unknown: "v.unknown()" };
+    return m[ref.type];
+  }
+  if (ref.kind === "array") return `v.array(${refToValibot(ref.elementType)})`;
+  return `${ref.name}Schema`;
+}
+function generateValibot(result, rootName) {
+  const { defs, rootRef } = result;
+  if (defs.length === 0) return `import * as v from "valibot";
+
+export const ${rootName}Schema = ${refToValibot(rootRef)};`;
+  const schemas = defs.map(({ name, fields }) => {
+    const lines = fields.map(({ key, type, nullable }) => {
+      const t = nullable ? `v.nullable(${refToValibot(type)})` : refToValibot(type);
+      const k = /[^a-zA-Z0-9_$]/.test(key) ? `"${key}"` : key;
+      return `  ${k}: ${t},`;
+    });
+    return `export const ${name}Schema = v.object({
+${lines.join("\n")}
+});`;
+  });
+  const rootAlias = rootRef.kind === "array" ? `
+export const ${rootName}Schema = v.array(${refToValibot(rootRef.elementType)});` : "";
+  return `import * as v from "valibot";
+
+${schemas.join("\n\n")}${rootAlias}`;
+}
+export {
+  generateJsonSchema,
+  generateOpenApi,
+  generateTypeScript,
+  generateValibot,
+  generateYup,
+  generateZod,
+  parseJson
+};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@aarunyaapps/json-to-types",
+  "version": "1.0.0",
+  "description": "Infer TypeScript, Zod, Valibot, Yup, JSON Schema, and OpenAPI 3 schemas from any JSON value. Zero dependencies.",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": ["dist", "README.md"],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "type-check": "tsc --noEmit"
+  },
+  "keywords": ["typescript", "zod", "valibot", "json-schema", "openapi", "type-generation", "codegen"],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aarunyaapps/json-to-types"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.8.3"
+  }
+}