ajsc 1.0.1 → 1.0.3

package/README.md

@@ -0,0 +1,145 @@
+# ajsc - Another JSON Schema Parser
+
+**ajsc** is an npm package that transforms JSON Schema definitions into an intermediate representation (IR) called `IRNode`. This intermediate form is designed to be consumed by language-specific converters—such as the built-in [TypeScript converter](#typescriptconverter)—or by any custom converter you create for languages like Kotlin or Swift. This library streamlines the process of converting API JSON Schema definitions into strong-typed code representations, ensuring consistency between your API contracts and client implementations.
+
+---
+
+## Features
+
+- **Comprehensive Schema Parsing:**  
+  Convert JSON Schema types including strings, numbers, booleans, nulls, literals, enums, unions, intersections, arrays, and objects into a unified IR.
+
+- **Intermediate Representation (`IRNode`):**  
+  The `IRNode` provides a standard structure that captures type, constraints, and path information. This representation is ideal for further transformation into various target languages.
+
+- **Plugin-Based Architecture:**  
+  Use the provided language plugin (currently, a [TypeScript converter](#typescriptconverter)) or write your own converter to support additional languages such as Kotlin or Swift.
+
+- **$defs and References Handling:**  
+  Resolve JSON Schema definitions (`$defs`) and references (`$ref`) seamlessly, ensuring reusable schema components are properly processed.
+
+- **Unique Signature Tracking:**  
+  For objects and arrays, the library tracks unique signatures to avoid duplicate type definitions when converting to code.
+
+---
+
+## Installation
+
+Install **ajsc** via npm:
+
+```bash
+npm install ajsc
+```
+
+## Usage
+### Basic Conversion to IRNode
+The primary function of ajsc is to convert a JSON Schema into an IRNode. Here’s an example of converting a simple JSON Schema that defines a string type:
+
+```javascript
+import { JSONSchemaConverter } from "ajsc";
+
+const schema = { type: "string" };
+const converter = new JSONSchemaConverter(schema);
+
+console.log(converter.irNode);
+// Output:
+// {
+//   type: "string",
+//   constraints: {},
+//   path: "",
+// }
+Converting Complex Schemas
+You can also convert more complex schemas including objects, arrays, unions, intersections, and even schemas with $defs:
+
+javascript
+Copy
+import { JSONSchemaConverter } from "ajsc";
+
+const complexSchema = {
+$defs: {
+Person: {
+type: "object",
+properties: {
+name: { type: "string" },
+age: { type: "number" },
+},
+required: ["name"],
+},
+},
+type: "object",
+properties: {
+person: { $ref: "#/$defs/Person" },
+},
+};
+
+const converter = new JSONSchemaConverter(complexSchema);
+console.log(converter.irNode);
+```
+
+## API Reference
+### JSONSchemaConverter
+- Constructor:
+ `new JSONSchemaConverter(schema: object)`
+- Properties:
+  - irNode: The resulting intermediate representation of the JSON Schema. 
+- Supported Schema Types:
+  - Primitive Types: string, number, boolean, null 
+  - Literals: Using the const keyword. 
+  - Enums: Using the enum property. 
+  - Unions: When type is an array (e.g., ["string", "number"]). 
+  - Intersections: Using allOf to combine multiple schemas. 
+  - Arrays: With type: "array" and an items schema. 
+  - Objects: With type: "object" and a properties definition.
+  - $defs and $ref: For defining and referencing reusable schema parts.
+
+### TypescriptConverter
+
+The package includes a TypeScript language plugin that converts the IRNode into TypeScript type definitions.
+
+- Constructor:
+`new TypescriptConverter(schema: object, options?: { inlineTypes?: boolean })`
+- Properties:
+  - code: A string containing the generated TypeScript code.
+  
+Usage Example:
+
+```javascript
+import { TypescriptConverter } from "ajsc";
+
+const schema = {
+  type: "object",
+  properties: {
+    name: { type: "string" },
+    age: { type: "number" },
+    contacts: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          email: { type: "string" },
+        },
+        required: ["email"],
+      },
+    },
+    profile: {
+      type: "object",
+      properties: {
+        email: { type: "string" },
+      },
+      required: ["email"],
+    },
+  },
+  required: ["name", "age"],
+};
+
+const tsConverter = new TypescriptConverter(schema, { inlineTypes: true });
+console.log(tsConverter.code);
+
+// Expected output (formatted):
+// {
+//   name: string;
+//   age: number;
+//   contacts?: Array<{ email: string; }>;
+//   profile?: { email: string; };
+// }
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ajsc",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Another Json-Schema Converter",
   "type": "module",
   "main": "./dist/index.js",
@@ -11,17 +11,10 @@
     "test": "vitest --run"
   },
   "exports": {
-    "./JSONSchemaConverter": {
-      "types": "./dist/JSONSchemaConverter.d.ts",
-      "default": "./dist/JSONSchemaConverter.js"
-    },
-    "./TypescriptConverter": {
-      "types": "./dist/TypescriptConverter.d.ts",
-      "default": "./dist/TypescriptConverter.js"
-    },
-    "./TypescriptProcedureConverter": {
-      "types": "./dist/TypescriptProcedureConverter.d.ts",
-      "default": "./dist/TypescriptProcedureConverter.js"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
     }
   },
   "keywords": [