@dinoconfig/cli 0.0.0

package/CHANGELOG.md

@@ -0,0 +1,33 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+- Initial release of the DinoConfig CLI
+- **`codegen` command** - Generate TypeScript type definitions from DinoConfig schemas
+  - Automatic brand/config/key type generation
+  - Configurable namespace and output path
+  - Full type safety with generated interfaces
+- **`javagen` command** - Generate Java model classes from DinoConfig schemas
+  - POJO class generation with proper types
+  - Lombok annotations support
+  - Package and output directory configuration
+- **Programmatic API** - Use CLI functionality in build scripts
+  - `generateTypes()` function for TypeScript generation
+  - `generateJavaModels()` function for Java generation
+- CLI entry points:
+  - `dinoconfig` - Main CLI with subcommands
+  - `dinoconfig-codegen` - Direct TypeScript generation
+  - `dinoconfig-javagen` - Direct Java generation
+- Full TypeScript support
+- Zero external runtime dependencies (uses `@dinoconfig/js-sdk`)
+
+### Documentation
+- Comprehensive README with usage examples
+- CI/CD integration guide
+- SDK usage examples with generated types

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-present DinoConfig Team
+
+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,157 @@
+# DinoConfig CLI
+
+[![npm version](https://img.shields.io/npm/v/@dinoconfig/cli.svg)](https://www.npmjs.com/package/@dinoconfig/cli)
+[![npm downloads](https://img.shields.io/npm/dm/@dinoconfig/cli.svg)](https://www.npmjs.com/package/@dinoconfig/cli)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Node.js](https://img.shields.io/badge/Node.js-18+-green.svg)](https://nodejs.org/)
+
+Command-line tools for DinoConfig, including TypeScript and Java code generation from your configuration schemas.
+
+## Installation
+
+```bash
+# npm
+npm install -g @dinoconfig/cli
+
+# npx (no install required)
+npx @dinoconfig/cli codegen --api-key=dino_xxx
+```
+
+## Commands
+
+### `codegen` - Generate TypeScript Types
+
+Generate TypeScript type definitions from your DinoConfig schemas for full type safety.
+
+```bash
+# Basic usage
+npx @dinoconfig/cli codegen --api-key=dino_your-api-key
+
+# Or use the shorthand command
+npx dinoconfig-codegen --api-key=dino_your-api-key
+
+# With all options
+npx @dinoconfig/cli codegen \
+  --api-key=dino_abc123 \
+  --baseUrl=https://api.dinoconfig.com \
+  --output=./src/types/dinoconfig.d.ts \
+  --namespace=AppConfig
+```
+
+#### Options
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `--api-key=<key>` | **Required.** Your DinoConfig API key | - |
+| `--baseUrl=<url>` | API base URL | `http://localhost:3000` |
+| `--output=<path>` | Output file path | `./src/types/dinoconfig.d.ts` |
+| `--namespace=<name>` | Root namespace name | `DinoConfig` |
+| `-h, --help` | Show help | - |
+| `-v, --version` | Show version | - |
+
+#### Generated Output
+
+The tool generates a TypeScript declaration file with:
+- A namespace for each brand
+- An interface for each config
+- Typed properties for each config key
+
+**Example generated code:**
+
+```typescript
+// src/types/dinoconfig.d.ts
+export namespace DinoConfig {
+  export namespace MyBrand {
+    /** FeatureFlags configuration */
+    export interface FeatureFlags {
+      /** boolean */
+      enableDarkMode: boolean;
+      /** number */
+      maxUploadSize: number;
+      /** string[] */
+      allowedCountries: string[];
+    }
+  }
+}
+```
+
+#### Usage with SDK
+
+```typescript
+import { dinoconfigApi } from '@dinoconfig/js-sdk';
+import { DinoConfig } from './types/dinoconfig';
+
+const dinoconfig = await dinoconfigApi({
+  apiKey: process.env.DINOCONFIG_API_KEY!
+});
+
+// Full type safety with generics
+const flags = await dinoconfig.configs.get<DinoConfig.MyBrand.FeatureFlags>(
+  'MyBrand',
+  'FeatureFlags'
+);
+
+// TypeScript knows the exact types!
+flags.data.values.enableDarkMode; // boolean ✓
+flags.data.values.maxUploadSize;  // number ✓
+```
+
+## Programmatic API
+
+You can also use the CLI programmatically in your build scripts:
+
+```typescript
+import { generateTypes } from '@dinoconfig/cli';
+
+async function generateConfigTypes() {
+  const result = await generateTypes({
+    apiKey: process.env.DINOCONFIG_API_KEY!,
+    baseUrl: 'https://api.dinoconfig.com',
+    output: './src/types/dinoconfig.d.ts',
+    namespace: 'DinoConfig',
+  });
+
+  if (result.success) {
+    console.log(`Generated ${result.stats.configs} config types`);
+  } else {
+    console.error('Failed:', result.error);
+  }
+}
+```
+
+## CI/CD Integration
+
+Add type generation to your build process:
+
+```json
+{
+  "scripts": {
+    "generate:types": "dinoconfig-codegen --api-key=$DINOCONFIG_API_KEY",
+    "build": "npm run generate:types && tsc"
+  }
+}
+```
+
+### GitHub Actions Example
+
+```yaml
+- name: Generate DinoConfig Types
+  run: npx @dinoconfig/cli codegen --api-key=${{ secrets.DINOCONFIG_API_KEY }}
+```
+
+## Requirements
+
+- Node.js >= 18.0.0
+- DinoConfig API key
+
+## Related Packages
+
+- [@dinoconfig/js-sdk](https://www.npmjs.com/package/@dinoconfig/js-sdk) - JavaScript/TypeScript SDK
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+---
+
+Made with ❤️ by the DinoConfig Team

package/bin/codegen.d.ts

@@ -0,0 +1,13 @@
+/**
+ * DinoConfig Type Generator CLI
+ *
+ * Generates TypeScript type definitions from DinoConfig schemas.
+ *
+ * @example
+ * ```bash
+ * npx @dinoconfig/cli codegen --api-key=dino_xxx --output=./src/types/dinoconfig.d.ts
+ * npx dinoconfig-codegen --api-key=dino_xxx
+ * ```
+ */
+export declare function runCodegen(args: string[]): Promise<void>;
+//# sourceMappingURL=codegen.d.ts.map

package/bin/codegen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codegen.d.ts","sourceRoot":"","sources":["../../../../libs/dinoconfig-cli/src/bin/codegen.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAoHH,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CA8C9D"}

package/bin/codegen.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+import { a as g } from "../codegen-DZxM8r9k.js";
+import { d as n, a as r, c, D as l, b as p } from "../constants-Dvwyqn-J.js";
+function f(s) {
+  const e = {};
+  for (const o of s)
+    o === "--help" || o === "-h" ? e.help = !0 : o === "--version" || o === "-v" ? e.version = !0 : o.startsWith("--api-key=") ? e.apiKey = o.slice(10) : o.startsWith("--baseUrl=") || o.startsWith("--base-url=") ? e.baseUrl = o.split("=")[1] : o.startsWith("--output=") || o.startsWith("-o=") ? e.output = o.split("=")[1] : o.startsWith("--namespace=") && (e.namespace = o.slice(12));
+  return e;
+}
+function u() {
+  console.log(`
+${n} v${r}
+
+Generate TypeScript types from DinoConfig schemas.
+
+USAGE:
+  npx ${n} --api-key=<key> [options]
+  npx @dinoconfig/cli codegen --api-key=<key> [options]
+
+OPTIONS:
+  --api-key=<key>       Required. Your DinoConfig API key
+  --baseUrl=<url>       API base URL (default: ${l})
+  --output=<path>       Output file path (default: ${c})
+  --namespace=<name>    Root namespace name (default: ${p})
+  -h, --help            Show this help message
+  -v, --version         Show version number
+
+EXAMPLES:
+  # Generate types with default settings
+  npx ${n} --api-key=dino_abc123
+
+  # Generate types to custom path
+  npx ${n} --api-key=dino_abc123 --output=./types/config.d.ts
+
+  # Use production API
+  npx ${n} --api-key=dino_abc123 --baseUrl=https://api.dinoconfig.com
+
+GENERATED OUTPUT:
+  The tool generates a TypeScript declaration file with:
+  - A namespace for each brand
+  - An interface for each config
+  - Typed properties for each config key
+
+  Example generated code:
+    export namespace DinoConfig {
+      export namespace MyBrand {
+        export interface FeatureFlags {
+          enableDarkMode: boolean;
+          maxUsers: number;
+        }
+      }
+    }
+
+  Usage with the SDK:
+    import { DinoConfig } from './types/dinoconfig';
+    
+    const flags = await dinoconfig.configs.get<DinoConfig.MyBrand.FeatureFlags>(
+      'MyBrand', 'FeatureFlags'
+    );
+    flags.data.values.enableDarkMode; // boolean ✓
+`);
+}
+function d(s, e, o) {
+  console.log(`
+🦖 ${n} v${r}
+`), console.log(`  Base URL:  ${s}`), console.log(`  Output:    ${e}`), console.log(`  Namespace: ${o}`), console.log("");
+}
+function h(s, e) {
+  console.log(`
+✅ Types generated successfully!
+`), console.log("  Usage in your code:"), console.log(""), console.log(`    import { ${e} } from '${s.replace(/\.d\.ts$/, "")}';`), console.log(""), console.log(`    const config = await dinoconfig.configs.get<${e}.BrandName.ConfigName>(`), console.log("      'BrandName', 'ConfigName'"), console.log("    );"), console.log("");
+}
+async function y(s) {
+  const e = f(s);
+  e.help && (u(), process.exit(0)), e.version && (console.log(`${n} v${r}`), process.exit(0)), e.apiKey || (console.error(`Error: --api-key is required
+`), console.error("Run with --help for usage information"), process.exit(1));
+  const o = e.baseUrl ?? l, t = e.output ?? c, i = e.namespace ?? p;
+  d(o, t, i), console.log("  → Initializing SDK..."), console.log("  → Fetching configuration schemas...");
+  const a = await g({
+    apiKey: e.apiKey,
+    baseUrl: o,
+    output: t,
+    namespace: i
+  });
+  a.success || (console.error(`
+❌ Error: ${a.error}`), process.exit(1)), console.log(`  → Found ${a.stats?.brands} brand(s)`), console.log(`  → Found ${a.stats?.configs} config(s) with ${a.stats?.keys} key(s)`), console.log("  → Generating TypeScript types..."), console.log(`  → Writing to ${t}...`), h(t, i);
+}
+process.argv[1]?.includes("codegen") && y(process.argv.slice(2)).catch((s) => {
+  const e = s instanceof Error ? s.message : "Unknown error";
+  console.error(`
+❌ Error:`, e), process.exit(1);
+});
+export {
+  y as runCodegen
+};

package/bin/dinoconfig.d.ts

@@ -0,0 +1,11 @@
+/**
+ * DinoConfig CLI - Main entry point
+ *
+ * @example
+ * ```bash
+ * npx @dinoconfig/cli codegen --api-key=dino_xxx
+ * npx @dinoconfig/cli --help
+ * ```
+ */
+export {};
+//# sourceMappingURL=dinoconfig.d.ts.map

package/bin/dinoconfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dinoconfig.d.ts","sourceRoot":"","sources":["../../../../libs/dinoconfig-cli/src/bin/dinoconfig.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG"}

package/bin/dinoconfig.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+import { C as o, a as s } from "../constants-Dvwyqn-J.js";
+function r() {
+  console.log(`
+${o} v${s}
+
+DinoConfig Command Line Interface
+
+USAGE:
+  npx ${o} <command> [options]
+
+COMMANDS:
+  codegen     Generate TypeScript types from DinoConfig schemas
+  javagen     Generate Java model classes from DinoConfig schemas
+
+OPTIONS:
+  -h, --help      Show this help message
+  -v, --version   Show version number
+
+EXAMPLES:
+  # Generate TypeScript types
+  npx ${o} codegen --api-key=dino_abc123
+
+  # Generate Java models
+  npx ${o} javagen --api-key=dino_abc123
+
+  # Show command help
+  npx ${o} codegen --help
+  npx ${o} javagen --help
+
+For more information, visit: https://docs.dinoconfig.com
+`);
+}
+function i(n) {
+  const e = n instanceof Error ? n.message : "Unknown error";
+  console.error("Error:", e), process.exit(1);
+}
+async function c() {
+  const n = process.argv.slice(2), e = n[0];
+  switch ((!e || e === "--help" || e === "-h") && (r(), process.exit(0)), (e === "--version" || e === "-v") && (console.log(`${o} v${s}`), process.exit(0)), e) {
+    case "codegen": {
+      const { runCodegen: a } = await import("./codegen.js");
+      await a(n.slice(1));
+      break;
+    }
+    case "javagen": {
+      const { runJavagen: a } = await import("./javagen.js");
+      await a(n.slice(1));
+      break;
+    }
+    default:
+      console.error(`Unknown command: ${e}`), console.error(`Run '${o} --help' for usage information`), process.exit(1);
+  }
+}
+c().catch(i);

package/bin/javagen.d.ts

@@ -0,0 +1,12 @@
+/**
+ * DinoConfig Java Model Generator CLI
+ *
+ * Generates Java POJO model classes from DinoConfig schemas.
+ *
+ * @example
+ * ```bash
+ * npx @dinoconfig/cli javagen --api-key=dino_xxx --output=./libs/dinoconfig-java-sdk/lib/src/main/java
+ * ```
+ */
+export declare function runJavagen(args: string[]): Promise<void>;
+//# sourceMappingURL=javagen.d.ts.map

package/bin/javagen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"javagen.d.ts","sourceRoot":"","sources":["../../../../libs/dinoconfig-cli/src/bin/javagen.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAoLH,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAuD9D"}

package/bin/javagen.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+import { g } from "../codegen-DZxM8r9k.js";
+import { a as c, C as i, D as l } from "../constants-Dvwyqn-J.js";
+const r = "./libs/dinoconfig-java-sdk/lib/src/main/java/com/dinoconfig/sdk/generated";
+function p(a) {
+  const o = {};
+  for (const e of a)
+    e === "--help" || e === "-h" ? o.help = !0 : e === "--version" || e === "-v" ? o.version = !0 : e.startsWith("--api-key=") ? o.apiKey = e.slice(10) : e.startsWith("--baseUrl=") || e.startsWith("--base-url=") ? o.baseUrl = e.split("=")[1] : e.startsWith("--output=") || e.startsWith("-o=") ? o.output = e.split("=")[1] : e.startsWith("--package=") || e.startsWith("-p=") ? o.package = e.split("=")[1] : (e === "--skip-deps" || e === "--no-deps") && (o.skipDeps = !0);
+  return o;
+}
+function d() {
+  console.log(`
+DinoConfig Java Model Generator v${c}
+
+Generate Java POJO model classes from DinoConfig schemas.
+
+USAGE:
+  npx ${i} javagen --api-key=<key> [options]
+
+OPTIONS:
+  --api-key=<key>       Required. Your DinoConfig API key
+  --baseUrl=<url>       API base URL (default: ${l})
+  --output=<path>       Output directory path (default: ${r})
+  --package=<pkg>       Base package for generated classes (auto-derived from output path)
+  --skip-deps           Skip automatic dependency update in build file
+  -h, --help            Show this help message
+  -v, --version         Show version number
+
+EXAMPLES:
+  # Generate Java models with default settings
+  npx ${i} javagen --api-key=dino_abc123
+
+  # Generate Java models to custom path (package auto-derived from path)
+  npx ${i} javagen --api-key=dino_abc123 --output=./src/main/java/org/example/models
+  # This will use package: org.example.models
+
+  # Generate with explicit package
+  npx ${i} javagen --api-key=dino_abc123 --output=./src/main/java/org/example/models --package=org.example.config
+
+  # Skip automatic dependency updates
+  npx ${i} javagen --api-key=dino_abc123 --skip-deps
+
+PACKAGE RESOLUTION:
+  The base package for generated classes is determined in this order:
+  1. Explicit --package option (if provided)
+  2. Auto-derived from --output path (looks for src/main/java/ pattern)
+  3. Default: com.dinoconfig.sdk.generated
+
+GENERATED OUTPUT:
+  The tool generates Java POJO classes:
+  - Each brand gets its own subpackage
+  - Each config gets its own class with typed fields
+  - Classes follow Java best practices (immutable, Jackson annotations, etc.)
+  - Automatically adds Jackson dependency to your build.gradle or pom.xml
+
+  Example with --output=./src/main/java/org/example/models:
+    org/example/models/
+      mybrand/
+        FeatureFlags.java    (package org.example.models.mybrand)
+        AppSettings.java
+
+DEPENDENCIES:
+  Generated models require Jackson for JSON serialization:
+  
+  Gradle:
+    implementation 'com.fasterxml.jackson.core:jackson-databind:2.16.1'
+    implementation 'com.fasterxml.jackson.core:jackson-annotations:2.16.1'
+  
+  Maven:
+    <dependency>
+      <groupId>com.fasterxml.jackson.core</groupId>
+      <artifactId>jackson-databind</artifactId>
+      <version>2.16.1</version>
+    </dependency>
+`);
+}
+function u(a, o, e) {
+  console.log(`
+🦖 DinoConfig Java Model Generator v${c}
+`), console.log(`  Base URL:  ${a}`), console.log(`  Output:    ${o}`), console.log(e ? `  Package:   ${e} (explicit)` : "  Package:   (auto-derived from output path)"), console.log("");
+}
+function f(a, o, e, n) {
+  if (console.log(`
+✅ Java models generated successfully!
+`), o && (console.log(`  Generated ${o.brands} brand(s)`), console.log(`  Generated ${o.configs} config class(es) with ${o.keys} field(s)`)), console.log(`  Output directory: ${a}`), n && console.log(`  Base package: ${n}`), e) {
+    if (console.log(""), e.success && e.addedDependencies && e.addedDependencies.length > 0) {
+      console.log(`  📦 Dependencies added to ${e.buildFilePath}:`);
+      for (const t of e.addedDependencies)
+        console.log(`     + ${t}`);
+    } else if (e.success && e.existingDependencies && e.existingDependencies.length > 0)
+      console.log(`  📦 Dependencies already present in ${e.buildFilePath}`);
+    else if (!e.success && e.error && (console.log(`  ⚠️  Could not update dependencies: ${e.error}`), e.warnings)) {
+      console.log(""), console.log("  Please add manually:");
+      for (const t of e.warnings)
+        console.log(`     ${t}`);
+    }
+  }
+  console.log(""), console.log("  Usage in your Java code:"), console.log(""), console.log(`    import ${n ?? "com.dinoconfig.sdk.generated"}.brandname.ConfigName;`), console.log("");
+}
+async function m(a) {
+  const o = p(a);
+  o.help && (d(), process.exit(0)), o.version && (console.log(`DinoConfig Java Model Generator v${c}`), process.exit(0)), o.apiKey || (console.error(`Error: --api-key is required
+`), console.error("Run with --help for usage information"), process.exit(1));
+  const e = o.baseUrl ?? l, n = o.output ?? r;
+  u(e, n, o.package), console.log("  → Initializing SDK..."), console.log("  → Fetching configuration schemas...");
+  const s = await g({
+    apiKey: o.apiKey,
+    baseUrl: e,
+    output: n,
+    package: o.package,
+    skipDependencyUpdate: o.skipDeps
+  });
+  s.success || (console.error(`
+❌ Error: ${s.error}`), process.exit(1)), console.log(`  → Found ${s.stats?.brands} brand(s)`), console.log(`  → Found ${s.stats?.configs} config(s) with ${s.stats?.keys} key(s)`), console.log(`  → Using package: ${s.basePackage}`), console.log("  → Generating Java model classes..."), console.log(`  → Writing to ${n}...`), o.skipDeps || (s.dependencyUpdate?.success && s.dependencyUpdate.addedDependencies?.length ? console.log("  → Updating project dependencies...") : s.dependencyUpdate?.success && console.log("  → Dependencies already present")), f(n, s.stats, s.dependencyUpdate, s.basePackage);
+}
+process.argv[1]?.includes("javagen") && m(process.argv.slice(2)).catch((a) => {
+  const o = a instanceof Error ? a.message : "Unknown error";
+  console.error(`
+❌ Error:`, o), process.exit(1);
+});
+export {
+  m as runJavagen
+};