// zynx.config.ts
import type { ZynxConfig } from "@atikayda/zynx/types";

export default {
  database: {
    type: "postgresql",
    connectionString: Deno.env.get("DATABASE_URL")!,
    ssl: Deno.env.get("NODE_ENV") === "production",
    pool: {
      min: 2,
      max: 10,
      timeout: 30000
    }
  },
  migrations: {
    directory: "./migrations",
    tableName: "zynx_migrations"
  },
  schema: {
    path: "./database.dbml"
  },
  features: ["kjson", "uuid-ossp"]
} satisfies ZynxConfig;

import { ZynxManager, loadConfig } from "@atikayda/zynx";

// Load configuration
const config = await loadConfig("./zynx.config.yaml");

// Create manager instance
const zynx = new ZynxManager(config);

// Generate migrations
const generateResult = await zynx.generate();
console.log(`Generated: ${generateResult.migrationFile}`);

// Apply migrations
const runResult = await zynx.run();
console.log(`Applied ${runResult.appliedMigrations.length} migrations`);

// Check status
const status = await zynx.status();
console.log(`Pending: ${status.pendingMigrations.length}`);

import { 
  ZynxManager, 
  loadConfig, 
  ZynxError,
  DatabaseError,
  SchemaError 
} from "@atikayda/zynx";

try {
  const config = await loadConfig();
  const zynx = new ZynxManager(config);
  
  // Generate with custom options
  const result = await zynx.generate({
    name: "add_user_profiles",
    force: false
  });
  
  if (result.hasChanges) {
    console.log(`Generated migration: ${result.migrationFile}`);
    
    // Apply with dry run first
    const dryRun = await zynx.run({ dryRun: true });
    console.log("Dry run successful, applying migrations...");
    
    const applied = await zynx.run();
    console.log(`Successfully applied ${applied.appliedMigrations.length} migrations`);
  } else {
    console.log("No schema changes detected");
  }
  
} catch (error) {
  if (error instanceof SchemaError) {
    console.error(`Schema error: ${error.message}`);
    if (error.lineNumber) {
      console.error(`At line ${error.lineNumber} in ${error.schemaPath}`);
    }
  } else if (error instanceof DatabaseError) {
    console.error(`Database error: ${error.message}`);
    if (error.query) {
      console.error(`Query: ${error.query}`);
    }
  } else if (error instanceof ZynxError) {
    console.error(`Zynx error: ${error.message}`);
  } else {
    console.error(`Unexpected error: ${error.message}`);
  }
  
  Deno.exit(1);
}

import { 
  loadConfig, 
  createConfig, 
  discoverConfigFile,
  isValidConfig 
} from "@atikayda/zynx/config";

// Discover config file automatically
const configPath = await discoverConfigFile();
console.log(`Found config: ${configPath}`);

// Load from specific path
const config = await loadConfig("./custom-config.yaml");

// Create config programmatically
const config = createConfig({
  database: {
    type: "postgresql",
    connectionString: "postgresql://localhost:5432/myapp"
  },
  migrations: {
    directory: "./db/migrations"
  },
  schema: {
    path: "./schema/database.dbml"
  }
});

// Validate configuration
if (isValidConfig(config)) {
  console.log("Configuration is valid");
}

import { 
  DBMLParser,
  TypeScriptGenerator,
  GoGenerator,
  PythonGenerator,
  RustGenerator 
} from "@atikayda/zynx";

// Parse DBML schema with features
const parser = new DBMLParser({
  typeMappings: {
    kinstant: "kinstant",
    kjson: "kjson",
    uuid: "uuid"
  }
});
const schema = await parser.parse(dbmlContent);

// Generate TypeScript types with feature support
const tsGenerator = new TypeScriptGenerator({
  addComments: true,
  enumStyle: "union",
  dateHandling: "Date",
  customTypes: {
    kinstant: "Instant",
    kjson: "any",
    uuid: "string"
  },
  imports: {
    Instant: "@atikayda/kjson"
  }
});
const tsTypes = tsGenerator.generateFile(schema);

// Generate Go structs
const goGenerator = new GoGenerator({
  namespace: "models"
});
const goTypes = goGenerator.generateFile(schema);

// Generate Python dataclasses
const pyGenerator = new PythonGenerator({
  pythonStyle: "pydantic"
});
const pyTypes = pyGenerator.generateFile(schema);

// Generate Rust structs
const rustGenerator = new RustGenerator({
  useSerde: true,
  deriveTraits: ["Debug", "Clone", "Serialize", "Deserialize"]
});
const rustTypes = rustGenerator.generateFile(schema);

import { 
  validateFeatures,
  listFeatures,
  getLanguageTypeMappings,
  getSQLTypeMappings 
} from "@atikayda/zynx/features";

// List all available features
const features = listFeatures();
console.log("Available features:");
features.forEach(f => {
  console.log(`- ${f.name}: ${f.description}`);
});

// Validate feature names
try {
  validateFeatures(["kjson", "uuid-ossp"]);
  console.log("Features are valid!");
} catch (error) {
  console.error("Invalid feature:", error.message);
}

// Get type mappings for a specific language
const { customTypes, imports } = getLanguageTypeMappings(
  ["kjson", "uuid-ossp"], 
  "typescript"
);
console.log("TypeScript types:", customTypes);
console.log("Required imports:", imports);

// Get SQL type mappings for DBML parser
const sqlMappings = getSQLTypeMappings(["kjson", "postgis"]);
console.log("SQL mappings:", sqlMappings);