klasik 2.0.8 → 2.2.0

package/README.md

@@ -1,12 +1,13 @@
 # Klasik
 
-Generate TypeScript clients from OpenAPI specifications, Kubernetes CRDs, and JSON Schema with full type safety and class-transformer support.
+Generate TypeScript clients from OpenAPI specifications, Kubernetes CRDs, JSON Schema, and Go structs with full type safety and class-transformer support.
 
 Perfect for:
 - 🚀 Kubernetes operators and controllers
 - 🔧 REST API clients with type safety
 - 📦 NestJS backend services
 - 🎯 Type-safe microservice communication
+- 🔄 Go-to-TypeScript code sharing
 
 ## Features
 
@@ -14,13 +15,14 @@ Perfect for:
 🎯 **Type-Safe** - Full TypeScript support with strict typing
 🔄 **class-transformer** - Automatic serialization/deserialization
 ✅ **class-validator** - Built-in validation decorators
+📋 **Ajv JSON Schema** - Draft 2020-12 validation with deep nesting support
 🎨 **NestJS Ready** - @ApiProperty decorators out of the box
-📦 **Multiple Formats** - OpenAPI, Kubernetes CRDs, JSON Schema
+📦 **Multiple Formats** - OpenAPI, Kubernetes CRDs, JSON Schema, Go structs
 🌐 **ESM Support** - Modern JavaScript modules with .js extensions
 🔗 **External $refs** - Automatic resolution of external schemas
 🎭 **Custom Templates** - Mustache-based customization
 ⚙️ **Flexible Output** - Multiple export styles (namespace, direct, both)
-🧪 **Well Tested** - Comprehensive test coverage (748 passing tests)
+🧪 **Well Tested** - Comprehensive test coverage (797 passing tests)
 🚀 **Production Ready** - Used in real-world projects
 📝 **Full CLI** - Rich command-line interface with 4 commands
 🔐 **Authentication** - Custom headers including Bearer tokens
@@ -62,6 +64,17 @@ klasik generate-jsonschema \
   --output ./src/generated
 ```
 
+Generate from Go structs (requires Go installed, auto-setup on first use):
+
+```bash
+klasik generate-go \
+  --type "helm.sh/helm/v3/pkg/chart.Metadata" \
+  --type "helm.sh/helm/v3/pkg/chart.Chart" \
+  --output ./src/generated \
+  --class-validator \
+  --nestjs-swagger
+```
+
 #### Bare Mode
 
 Generate models directly in the output directory without wrapper structure:
@@ -238,6 +251,416 @@ const tasks = await api.listTasks();
 
 For more details, see the [Validation Guide](./docs/validation.md).
 
+## Ajv JSON Schema Validation
+
+Klasik can generate Ajv-based JSON Schema validation alongside or instead of class-validator decorators. This provides comprehensive JSON Schema Draft 2020-12 validation with deep nested object support and optimized performance.
+
+### Why Ajv Validation?
+
+**Advantages over class-validator:**
+- ✅ **Full JSON Schema compliance** - Supports all Draft 2020-12 features
+- ✅ **Deep nested validation** - Automatically validates nested objects at all levels
+- ✅ **Performance optimized** - Schema compilation is cached per class
+- ✅ **Standards-based** - Uses industry-standard JSON Schema format
+- ✅ **Independent** - Works alongside or without class-validator
+
+**When to use:**
+- Complex nested object structures (User → Address → Coordinates)
+- JSON Schema-first development workflows
+- Need for format validation (email, uuid, date-time, etc.)
+- Projects requiring JSON Schema compliance
+- High-performance validation scenarios
+
+### Basic Usage
+
+Enable with the `--use-ajv` flag:
+
+```bash
+klasik generate \
+  --url https://api.example.com/openapi.json \
+  --output ./generated \
+  --use-ajv
+```
+
+### Generated Code Structure
+
+Each generated class includes:
+
+1. **`static getSchema()`** - Returns the JSON Schema
+2. **`static validateWithJsonSchema(data)`** - Validates data against the schema
+3. **Private cached validator** - Optimized for performance
+
+**Example generated class:**
+
+```typescript
+import { Ajv } from "ajv";
+import { addFormats } from "ajv-formats";
+import { Expose } from "class-transformer";
+
+export class User {
+  /**
+   * Get JSON Schema for User
+   * @returns JSON Schema Draft 2020-12
+   */
+  static getSchema(): object {
+    return {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "email": {
+          "type": "string",
+          "format": "email"
+        },
+        "address": {
+          "type": "object"
+        }
+      },
+      "additionalProperties": false,
+      "required": ["name", "email"]
+    };
+  }
+
+  private static _ajvInstance: Ajv | null = null;
+  private static _compiledValidator: any = null;
+
+  /** Get or create Ajv instance for User */
+  private static getAjvInstance(): Ajv {
+    if (!this._ajvInstance) {
+      this._ajvInstance = new Ajv({ allErrors: true, strict: false });
+      addFormats(this._ajvInstance);
+    }
+    return this._ajvInstance;
+  }
+
+  /** Get or create compiled validator for User (cached for performance) */
+  private static getCompiledValidator(): any {
+    if (!this._compiledValidator) {
+      const ajv = this.getAjvInstance();
+      const schema = this.getSchema();
+      this._compiledValidator = ajv.compile(schema);
+    }
+    return this._compiledValidator;
+  }
+
+  /**
+   * Validate data against JSON Schema with recursive nested validation
+   * @param data - Data to validate
+   * @returns Validation result with errors if any
+   */
+  static validateWithJsonSchema(data: unknown): { valid: boolean; errors: any[] } {
+    const validate = this.getCompiledValidator();
+    const valid = validate(data);
+
+    // Collect errors
+    const allErrors: any[] = validate.errors || [];
+
+    // Recursively validate nested objects that have validateWithJsonSchema method
+    if (valid && typeof data === "object" && data !== null) {
+      for (const [key, value] of Object.entries(data)) {
+        if (value && typeof value === "object") {
+          const constructor = (value as any).constructor;
+          if (constructor && typeof constructor.validateWithJsonSchema === "function") {
+            const nestedResult = constructor.validateWithJsonSchema(value);
+            if (!nestedResult.valid) {
+              allErrors.push(...nestedResult.errors.map((e: any) => ({
+                ...e,
+                instancePath: `/${key}${e.instancePath || ""}`
+              })));
+            }
+          }
+        }
+      }
+    }
+
+    return { valid: allErrors.length === 0, errors: allErrors };
+  }
+
+  @Expose()
+  name: string;
+
+  @Expose()
+  email: string;
+
+  @Expose()
+  address?: Address;
+}
+```
+
+### Using Validation Methods
+
+**Valid data:**
+
+```typescript
+import { User } from './generated/models';
+
+const userData = {
+  name: 'John Doe',
+  email: 'john@example.com'
+};
+
+const result = User.validateWithJsonSchema(userData);
+
+if (result.valid) {
+  console.log('✅ Data is valid!');
+} else {
+  console.error('❌ Validation failed:', result.errors);
+}
+```
+
+**Invalid data:**
+
+```typescript
+const invalidData = {
+  name: '',  // minLength: 1 violation
+  email: 'not-an-email'  // format: email violation
+};
+
+const result = User.validateWithJsonSchema(invalidData);
+
+console.log(result);
+// {
+//   valid: false,
+//   errors: [
+//     {
+//       instancePath: '/name',
+//       schemaPath: '#/properties/name/minLength',
+//       keyword: 'minLength',
+//       params: { limit: 1 },
+//       message: 'must NOT have fewer than 1 characters'
+//     },
+//     {
+//       instancePath: '/email',
+//       schemaPath: '#/properties/email/format',
+//       keyword: 'format',
+//       params: { format: 'email' },
+//       message: 'must match format "email"'
+//     }
+//   ]
+// }
+```
+
+### Deep Nested Validation
+
+The validator automatically validates nested objects recursively:
+
+```typescript
+import { User, Address } from './generated/models';
+
+// Create nested structure
+const address = new Address();
+address.street = '';  // Invalid: minLength violation
+address.city = 'Springfield';
+address.zipCode = 'INVALID';  // Invalid: pattern violation
+
+const user = {
+  name: 'John Doe',
+  email: 'john@example.com',
+  address  // Nested object
+};
+
+const result = User.validateWithJsonSchema(user);
+
+console.log(result);
+// {
+//   valid: false,
+//   errors: [
+//     {
+//       instancePath: '/address/street',
+//       keyword: 'minLength',
+//       message: 'must NOT have fewer than 1 characters'
+//     },
+//     {
+//       instancePath: '/address/zipCode',
+//       keyword: 'pattern',
+//       message: 'must match pattern "^[0-9]{5}$"'
+//     }
+//   ]
+// }
+```
+
+**Note:** Error paths include the full nested path (`/address/street`), making it easy to identify exactly where validation failed.
+
+### Supported Validations
+
+All JSON Schema Draft 2020-12 validation keywords are supported:
+
+**String constraints:**
+- `minLength`, `maxLength`
+- `pattern` (regex)
+- `format` (email, uuid, date-time, uri, etc.)
+
+**Numeric constraints:**
+- `minimum`, `maximum`
+- `exclusiveMinimum`, `exclusiveMaximum`
+- `multipleOf`
+
+**Array constraints:**
+- `minItems`, `maxItems`
+- `uniqueItems`
+
+**Object constraints:**
+- `required` properties
+- `additionalProperties`
+
+**Other:**
+- `enum` values
+- `nullable` types
+- Union types with `anyOf`
+
+### Performance Optimization
+
+The generated code includes **compilation caching** for optimal performance:
+
+```typescript
+// First validation: Schema is compiled and cached
+User.validateWithJsonSchema(data1);  // Compile + Validate
+
+// Subsequent validations: Uses cached compiled validator
+User.validateWithJsonSchema(data2);  // Validate only (fast!)
+User.validateWithJsonSchema(data3);  // Validate only (fast!)
+```
+
+**Benefits:**
+- Schema compiled once per class, not per validation
+- Significant performance improvement for repeated validations
+- Singleton Ajv instance shared across validations
+
+### Combining with class-validator
+
+You can use both validation approaches together:
+
+```bash
+klasik generate \
+  --url https://api.example.com/openapi.json \
+  --output ./generated \
+  --class-validator \
+  --use-ajv
+```
+
+**Generated class has both:**
+
+```typescript
+export class User {
+  // class-validator decorators
+  @IsString()
+  @MinLength(1)
+  @Expose()
+  name: string;
+
+  @IsEmail()
+  @Expose()
+  email: string;
+
+  // PLUS Ajv validation methods
+  static getSchema(): object { /* ... */ }
+  static validateWithJsonSchema(data: unknown) { /* ... */ }
+}
+```
+
+**Use case:** Runtime validation with class-validator in NestJS controllers, plus JSON Schema validation for external integrations.
+
+### Dependencies
+
+When using `--use-ajv`, the following dependencies are automatically added to `package.json`:
+
+```json
+{
+  "dependencies": {
+    "ajv": "^8.12.0",
+    "ajv-formats": "^2.1.1"
+  }
+}
+```
+
+Install them in your project:
+
+```bash
+cd generated
+npm install
+```
+
+### Complete Example
+
+```bash
+# Generate models with Ajv validation
+klasik generate-jsonschema \
+  --url ./schemas/user.json \
+  --output ./src/models \
+  --use-ajv
+
+# Use in your code
+cat > example.ts << 'EOF'
+import { User } from './src/models';
+
+// Valid user
+const validUser = {
+  name: 'Alice Smith',
+  email: 'alice@example.com',
+  age: 30
+};
+
+const result1 = User.validateWithJsonSchema(validUser);
+console.log('Valid:', result1.valid);  // true
+
+// Invalid user
+const invalidUser = {
+  name: '',  // Too short
+  email: 'invalid-email',
+  age: -5  // Negative age
+};
+
+const result2 = User.validateWithJsonSchema(invalidUser);
+console.log('Valid:', result2.valid);  // false
+console.log('Errors:', result2.errors);
+// [
+//   { instancePath: '/name', message: 'must NOT have fewer than 1 characters' },
+//   { instancePath: '/email', message: 'must match format "email"' },
+//   { instancePath: '/age', message: 'must be >= 0' }
+// ]
+EOF
+
+npx ts-node example.ts
+```
+
+### Advanced: Accessing the JSON Schema
+
+You can access the generated JSON Schema directly:
+
+```typescript
+import { User } from './generated/models';
+
+// Get the schema
+const schema = User.getSchema();
+
+console.log(JSON.stringify(schema, null, 2));
+// {
+//   "$schema": "https://json-schema.org/draft/2020-12/schema",
+//   "type": "object",
+//   "properties": {
+//     "name": { "type": "string", "minLength": 1 },
+//     "email": { "type": "string", "format": "email" }
+//   },
+//   "required": ["name", "email"],
+//   "additionalProperties": false
+// }
+
+// Use with external JSON Schema validators
+import Ajv from 'ajv';
+const ajv = new Ajv();
+const validate = ajv.compile(User.getSchema());
+validate(data);
+```
+
+**Use cases:**
+- Generating OpenAPI documentation
+- Sharing schemas with other systems
+- Custom validation workflows
+- Schema introspection
+
 ## CLI Commands
 
 ### `klasik generate`
@@ -262,6 +685,7 @@ klasik generate [options]
 | `--skip-js-extensions` | Skip .js extensions (for bundlers) | `false` |
 | `--nestjs-swagger` | Add @ApiProperty decorators | `false` |
 | `--class-validator` | Add class-validator decorators | `false` |
+| `--use-ajv` | Add Ajv JSON Schema validation methods | `false` |
 | `--header <header>` | Custom header (repeatable) | - |
 | `--timeout <ms>` | Request timeout | `30000` |
 | `--template <dir>` | Custom template directory | - |
@@ -292,6 +716,19 @@ klasik generate \
   --nestjs-swagger \
   --class-validator
 
+# With Ajv JSON Schema validation
+klasik generate \
+  --url https://api.example.com/spec.json \
+  --output ./src/api \
+  --use-ajv
+
+# With both class-validator and Ajv
+klasik generate \
+  --url https://api.example.com/spec.json \
+  --output ./src/api \
+  --class-validator \
+  --use-ajv
+
 # With external refs and authentication
 klasik generate \
   --url https://api.example.com/spec.json \
@@ -373,6 +810,7 @@ klasik generate-crd [options]
 | `--crd-kind-case <format>` | Folder naming: `pascal`, `snake`, `kebab` | `pascal` |
 | `--nestjs-swagger` | Add @ApiProperty decorators | `false` |
 | `--class-validator` | Add class-validator decorators | `false` |
+| `--use-ajv` | Add Ajv JSON Schema validation methods | `false` |
 | `--esm` | Add .js extensions for ESM | `false` |
 | `--header <header>` | Custom header (repeatable) | - |
 | `--resolve-refs` | Resolve external $ref files | `false` |
@@ -428,6 +866,7 @@ klasik generate-jsonschema [options]
 | `-o, --output <dir>` | Output directory (required) | - |
 | `--nestjs-swagger` | Add @ApiProperty decorators | `false` |
 | `--class-validator` | Add class-validator decorators | `false` |
+| `--use-ajv` | Add Ajv JSON Schema validation methods | `false` |
 | `--esm` | Add .js extensions for ESM | `false` |
 | `--header <header>` | Custom header (repeatable) | - |
 | `--resolve-refs` | Resolve external $ref files | `false` |
@@ -455,8 +894,87 @@ klasik generate-jsonschema \
   --output ./src/types \
   --nestjs-swagger \
   --class-validator
+
+# With Ajv JSON Schema validation
+klasik generate-jsonschema \
+  --url ./schemas/user.json \
+  --output ./src/types \
+  --use-ajv
+```
+
+### `klasik generate-go`
+
+Generate TypeScript models from Go structs using runtime reflection.
+
+**Usage:**
+
+```bash
+klasik generate-go [options]
 ```
 
+**Options:**
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `-t, --type <type>` | Go type path (package.Type) (repeatable, required) | - |
+| `-o, --output <dir>` | Output directory (required) | - |
+| `--nestjs-swagger` | Add @ApiProperty decorators | `false` |
+| `--class-validator` | Add class-validator decorators | `false` |
+| `--use-ajv` | Add Ajv JSON Schema validation methods | `false` |
+| `--esm` | Add .js extensions for ESM | `false` |
+| `--template <dir>` | Custom template directory | - |
+| `--export-style <style>` | Export style: `namespace`, `direct`, `both`, `none` | `namespace` |
+| `--bare` | Generate models directly in output dir | `false` |
+| `--go-tool-path <path>` | Path to go-schema-gen binary | auto-detected |
+| `--allow-additional-properties` | Allow additional properties in JSON Schema | `false` |
+
+**Prerequisites:**
+- Go 1.21+ must be installed (first-time setup is automatic)
+- Types must be registered in `tools/go-schema-gen/registry.go`
+
+**Examples:**
+
+```bash
+# Generate from Helm chart types
+klasik generate-go \
+  --type "helm.sh/helm/v3/pkg/chart.Metadata" \
+  --type "helm.sh/helm/v3/pkg/chart.Chart" \
+  --output ./src/helm-types \
+  --nestjs-swagger \
+  --class-validator
+
+# Generate with Ajv validation
+klasik generate-go \
+  --type "helm.sh/helm/v3/pkg/chart.Metadata" \
+  --output ./src/types \
+  --use-ajv
+
+# Generate for ESM
+klasik generate-go \
+  --type "helm.sh/helm/v3/pkg/chart.Chart" \
+  --output ./src/types \
+  --esm
+```
+
+**How it works:**
+1. Uses Go reflection via `invopop/jsonschema` library
+2. Generates JSON Schema from Go structs
+3. Feeds to existing JsonSchemaParser
+4. Generates TypeScript with full type safety
+
+**Adding new types:**
+
+Edit `tools/go-schema-gen/registry.go`:
+```go
+import mypackage "github.com/org/package"
+
+var typeRegistry = map[string]interface{}{
+    "github.com/org/package.MyStruct": mypackage.MyStruct{},
+}
+```
+
+Then rebuild: `cd tools/go-schema-gen && ./build.sh`
+
 ## Kubernetes CRD Support
 
 Klasik can generate TypeScript models directly from Kubernetes CustomResourceDefinitions (CRDs). Perfect for working with custom Kubernetes resources like ArgoCD Applications, Cert-Manager Certificates, or your own custom resources.
@@ -573,6 +1091,193 @@ const pkg: Package = {
 // Full TypeScript intellisense and type checking!
 ```
 
+## Go Struct Support
+
+Klasik can generate TypeScript models from Go structs using runtime reflection. Perfect for sharing types between Go backends and TypeScript frontends, or for generating types from existing Go packages like Helm, Kubernetes, or your own custom packages.
+
+### Features
+
+- ✅ **Runtime reflection** - Uses Go's reflection API with `invopop/jsonschema`
+- ✅ **Struct tag support** - Respects `json`, `yaml`, `jsonschema` tags
+- ✅ **Multiple types** - Generate from multiple structs in one command
+- ✅ **Automatic references** - Nested types resolved with $ref
+- ✅ **Full decorator support** - NestJS, class-validator, class-transformer, Ajv
+- ✅ **Production-ready** - Tested with Helm chart types
+
+### Prerequisites
+
+- **Go 1.21+** must be installed (download from [go.dev](https://go.dev/dl/))
+- Types must be registered in `tools/go-schema-gen/registry.go`
+
+**Note:** The first time you use `generate-go`, Klasik will automatically:
+1. Check if Go is installed
+2. Download Go dependencies (`go mod tidy`)
+3. Build the Go schema generator tool
+
+This only happens once - subsequent runs use the cached binary.
+
+### How It Works
+
+1. Go tool uses reflection to inspect struct at runtime
+2. Generates JSON Schema Draft 2020-12
+3. Feeds to existing JsonSchemaParser
+4. Generates TypeScript with full type safety
+
+**Architecture:**
+```
+Go Struct → Reflection → JSON Schema → JsonSchemaParser → IR → TypeScript
+```
+
+### Quick Start
+
+First-time users: Just run the command! Klasik will automatically set up everything:
+
+```bash
+klasik generate-go \
+  --type "helm.sh/helm/v3/pkg/chart.Metadata" \
+  --output ./src/helm-types
+
+# Output:
+# Building Go schema generator (first time only)...
+# Installing Go dependencies...
+# Compiling Go tool...
+# ✓ Go tool built successfully
+# ✔ Generation complete!
+```
+
+Subsequent runs are instant (no rebuild needed):
+
+```bash
+klasik generate-go \
+  --type "helm.sh/helm/v3/pkg/chart.Chart" \
+  --output ./src/helm-types \
+  --nestjs-swagger \
+  --class-validator
+```
+
+### Struct Tag Mapping
+
+Go struct tags are automatically converted to JSON Schema:
+
+| Go Tag | Effect | JSON Schema |
+|--------|--------|-------------|
+| `json:"fieldName"` | Property name | `"properties": {"fieldName": {...}}` |
+| `json:",omitempty"` | Optional field | Not in `"required"` array |
+| `jsonschema:"required"` | Force required | Added to `"required"` array |
+| `jsonschema:"minLength=5"` | Validation | `"minLength": 5` |
+| `jsonschema:"pattern=^[A-Z]"` | Regex | `"pattern": "^[A-Z]"` |
+| `jsonschema_description:"..."` | Documentation | `"description": "..."` |
+
+**Example Go Struct:**
+```go
+type Metadata struct {
+    Name        string `json:"name" jsonschema:"required,minLength=1"`
+    Version     string `json:"version" jsonschema:"required"`
+    Description string `json:"description,omitempty"`
+}
+```
+
+**Generated TypeScript:**
+```typescript
+export class Metadata {
+  @ApiProperty()
+  @IsString()
+  name: string;
+
+  @ApiProperty()
+  @IsString()
+  version: string;
+
+  @ApiProperty({ required: false })
+  @IsOptional()
+  @IsString()
+  description?: string;
+}
+```
+
+### Adding New Types
+
+To add new Go packages/types:
+
+1. Edit `tools/go-schema-gen/registry.go`:
+```go
+import (
+    chart "helm.sh/helm/v3/pkg/chart"
+    mypackage "github.com/org/package"
+)
+
+var typeRegistry = map[string]interface{}{
+    // Existing types
+    "helm.sh/helm/v3/pkg/chart.Metadata": chart.Metadata{},
+
+    // Add your types
+    "github.com/org/package.MyStruct": mypackage.MyStruct{},
+}
+```
+
+2. Update dependencies:
+```bash
+cd tools/go-schema-gen
+go mod tidy
+```
+
+3. Rebuild the tool:
+```bash
+./build.sh
+```
+
+4. Use your new type:
+```bash
+klasik generate-go \
+  --type "github.com/org/package.MyStruct" \
+  --output ./src/types
+```
+
+### Limitations
+
+- **Type Registry Required** - Types must be pre-registered (no dynamic loading)
+- **Requires Recompilation** - Adding new packages requires rebuilding the Go tool
+- **Go Installation** - Go must be installed on the system
+
+### Troubleshooting
+
+**"Go is not installed" error:**
+```bash
+# Install Go from https://go.dev/dl/
+# On macOS with Homebrew:
+brew install go
+
+# Verify installation:
+go version
+```
+
+**"Failed to build Go tool" error:**
+```bash
+# Try manual build:
+cd tools/go-schema-gen
+./build.sh
+
+# Or rebuild from scratch:
+rm -rf ../../dist/bin/go-schema-gen
+klasik generate-go --type "..." --output ...
+```
+
+**Rebuild the Go tool manually:**
+```bash
+cd tools/go-schema-gen
+go mod tidy
+./build.sh
+```
+
+### Future Enhancements
+
+Planned features for future releases:
+- Go Plugin support for dynamic loading
+- Auto-discovery of types in packages
+- `validate` tag support
+- Custom type mappings
+- Multi-platform pre-built binaries
+
 ## NestJS Integration
 
 Klasik integrates seamlessly with NestJS, generating models with `@ApiProperty` decorators for automatic Swagger/OpenAPI documentation and `class-validator` decorators for runtime validation.
@@ -890,6 +1595,8 @@ Built with:
 - [ts-morph](https://github.com/dsherret/ts-morph) - TypeScript Compiler API wrapper
 - [class-transformer](https://github.com/typestack/class-transformer) - Object transformation
 - [class-validator](https://github.com/typestack/class-validator) - Runtime validation
+- [ajv](https://github.com/ajv-validator/ajv) - JSON Schema validator
+- [ajv-formats](https://github.com/ajv-validator/ajv-formats) - Format validation for Ajv
 - [mustache](https://github.com/janl/mustache.js) - Template engine
 - [commander](https://github.com/tj/commander.js) - CLI framework