A powerful TypeScript library for building, manipulating, and transforming JSON schemas with a fluent API.

• 🛠️ Fluent API for schema manipulation
• 🔄 Pick and omit properties from schemas
• ⚡ Dynamic property updates
• 🔒 Required/optional property management
• 📦 Array schema conversion
• 🔄 Reference removal
• 🧬 Type-safe operations

npm install @codeperate/json-schema-builder

import { schemaBuilder } from '@codeperate/json-schema-builder';

// Create a schema
const schema = {
  type: 'object',
  properties: {
    name: { type: 'string' },
    age: { type: 'integer' },
    email: { type: 'string' },
    address: {
      type: 'object',
      properties: {
        street: { type: 'string' },
        city: { type: 'string' },
      },
      required: ['street', 'city'],
    },
  },
  required: ['name', 'age', 'email', 'address'],
};

// Use the builder to transform the schema
const updatedSchema = schemaBuilder(schema).pick(['name', 'email']).schema;

console.log(updatedSchema);

Creates a new SchemaBuilder instance.

• pick(props: (keyof T)[] | RegExp, options?: { removeRequired?: boolean }): SchemaBuilder<T>

  • Select specific properties from the schema
  • Optionally remove required properties

• omit(props: (keyof T)[] | RegExp, options?: { removeRequired?: boolean }): SchemaBuilder<T>

  • Remove specific properties from the schema
  • Optionally remove required properties

• optional(props: (keyof T)[]): SchemaBuilder<T>

  • Make specified properties optional

• required(props: (keyof T)[]): SchemaBuilder<T>

  • Make specified properties required

• set<K extends keyof JSONSchema>(key: K, value: JSONSchema[K] | ((curVal: JSONSchema[K]) => JSONSchema[K])): SchemaBuilder<T>

  • Set a schema property directly

• setProps<K extends keyof T, V extends JSONSchema>(key: K, value: V | ((curVal: JSONSchema) => V)): SchemaBuilder<Omit<T, K> & { [key in K]: FromSchema<V> }>

  • Set a property with type safety

• setPropsRaw<K extends keyof T, V = any>(key: K, value: JSONSchema | ((curVal: JSONSchema) => JSONSchema)): SchemaBuilder<Omit<T, K> & { [key in K]: V }>

  • Set a property without type constraints

• clone(): SchemaBuilder<T>

  • Create a deep copy of the current schema

• toArray(): SchemaBuilder<Array<T>>

  • Convert the schema to an array schema

• noRef(options?: { removeRequired?: boolean }): SchemaBuilder<T>

  • Remove all references from the schema

const schema = schemaBuilder(originalSchema).pick(['name', 'email']).schema;

const schema = schemaBuilder(originalSchema).optional(['age', 'address']).schema;

const arraySchema = schemaBuilder(originalSchema).toArray().schema;

const cleanSchema = schemaBuilder(originalSchema).noRef().schema;

Contributions are welcome! Please feel free to submit a Pull Request.

This project is licensed under the MIT License - see the LICENSE file for details.