@takyonic/cli 1.0.2

package/src/dsl-to-json.ts

@@ -0,0 +1,99 @@
+/**
+ * DSL to JSON Converter
+ * Converts parsed Takyonic DSL schema to JSON format expected by server
+ */
+
+import { TakyonicSchema, TableDefinition } from './parser';
+import { dslTypeToPostgres } from './type-mapper';
+
+export interface ColumnSchema {
+  name: string;
+  data_type: string;
+  nullable: boolean;
+  default_value?: string;
+}
+
+export interface IndexInfo {
+  name: string;
+  columns: string[];
+  unique: boolean;
+}
+
+export interface TableSchema {
+  name: string;
+  columns: ColumnSchema[];
+  indexes?: IndexInfo[];
+  foreign_keys?: any[];
+  cache_ttl?: number;
+}
+
+/**
+ * Convert Takyonic DSL schema to server JSON format
+ */
+export function dslToJson(schema: TakyonicSchema): TableSchema[] {
+  return schema.tables.map(table => convertTable(table));
+}
+
+/**
+ * Convert a single table definition to server format
+ */
+function convertTable(table: TableDefinition): TableSchema {
+  const columns: ColumnSchema[] = [];
+  const indexes: IndexInfo[] = [];
+  const primaryKeyColumns: string[] = [];
+
+  // Convert fields to columns
+  for (const field of table.fields) {
+    const postgresType = dslTypeToPostgres(field.type);
+    
+    // Check if field is nullable (default to false, unless explicitly marked)
+    // For now, we'll assume all fields are non-nullable unless we add nullable decorator
+    const nullable = false;
+
+    columns.push({
+      name: field.name,
+      data_type: postgresType,
+      nullable,
+      default_value: field.decorators.default,
+    });
+
+    // Track primary key fields
+    if (field.decorators.primary) {
+      primaryKeyColumns.push(field.name);
+    }
+  }
+
+  // Create primary key index if we have primary key fields
+  if (primaryKeyColumns.length > 0) {
+    indexes.push({
+      name: `${table.name}_pkey`,
+      columns: primaryKeyColumns,
+      unique: true,
+    });
+  }
+
+  // Always ensure we have an 'id' column for Takyonic (if not present, add it)
+  const hasIdColumn = columns.some(col => col.name === 'id');
+  if (!hasIdColumn && primaryKeyColumns.length === 0) {
+    // Add id column if no primary key is defined
+    columns.unshift({
+      name: 'id',
+      data_type: 'text',
+      nullable: false,
+    });
+    
+    indexes.push({
+      name: `${table.name}_pkey`,
+      columns: ['id'],
+      unique: true,
+    });
+  }
+
+  return {
+    name: table.name,
+    columns,
+    indexes: indexes.length > 0 ? indexes : undefined,
+    foreign_keys: [],
+  };
+}
+

package/src/generator.ts

@@ -0,0 +1,178 @@
+interface ColumnSchema {
+  name: string;
+  data_type: string;
+  nullable: boolean;
+}
+
+interface TableSchema {
+  name: string;
+  columns: ColumnSchema[];
+}
+
+/**
+ * Maps PostgreSQL data types to TypeScript types
+ */
+function mapPostgresToTypeScript(dataType: string): string {
+  const normalized = dataType.toLowerCase();
+  
+  switch (normalized) {
+    case 'text':
+    case 'varchar':
+    case 'character varying':
+    case 'char':
+    case 'uuid':
+      return 'string';
+    case 'integer':
+    case 'int':
+    case 'int4':
+    case 'bigint':
+    case 'int8':
+    case 'numeric':
+    case 'decimal':
+    case 'double precision':
+    case 'real':
+    case 'float':
+    case 'smallint':
+    case 'int2':
+      return 'number';
+    case 'boolean':
+    case 'bool':
+      return 'boolean';
+    case 'jsonb':
+    case 'json':
+      return 'Record<string, unknown>';
+    case 'timestamp':
+    case 'timestamp without time zone':
+    case 'timestamp with time zone':
+    case 'date':
+    case 'time':
+    case 'time without time zone':
+    case 'time with time zone':
+      return 'Date';
+    default:
+      return 'unknown';
+  }
+}
+
+/**
+ * Converts table name to PascalCase for interface names
+ */
+function toPascalCase(str: string): string {
+  return str
+    .split('_')
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join('');
+}
+
+/**
+ * Generates TypeScript interface for a table
+ */
+function generateInterface(table: TableSchema): string {
+  const interfaceName = toPascalCase(table.name);
+  const columns = table.columns
+    .map(col => {
+      const tsType = mapPostgresToTypeScript(col.data_type);
+      const optional = col.nullable ? '?' : '';
+      return `  ${col.name}${optional}: ${tsType};`;
+    })
+    .join('\n');
+  
+  return `export interface ${interfaceName} {\n${columns}\n}`;
+}
+
+/**
+ * Generates TypeScript code from schema
+ * 
+ * This generates type definitions that work with the @takyonic/sdk package.
+ * Instead of generating a full client, it produces interfaces that can be
+ * used with the SDK's generic table methods.
+ */
+export function generateTypeScript(schema: TableSchema[]): string {
+  const interfaces = schema.map(generateInterface).join('\n\n');
+  
+  // Generate table name type union
+  const tableNames = schema.map(t => `'${t.name}'`).join(' | ');
+  
+  // Generate table type mapping
+  const tableTypeMap = schema
+    .map(t => `  ${t.name}: ${toPascalCase(t.name)};`)
+    .join('\n');
+
+  // Generate usage examples
+  const exampleTable = schema[0];
+  const exampleType = exampleTable ? toPascalCase(exampleTable.name) : 'YourTable';
+  const exampleName = exampleTable ? exampleTable.name : 'your_table';
+
+  const code = `/**
+ * Auto-generated by Takyonic CLI
+ * 
+ * This file contains TypeScript interfaces for your database schema.
+ * Use these types with the @takyonic/sdk package for type-safe queries.
+ * 
+ * Do not edit this file manually - regenerate with: takyonic-cli generate
+ */
+
+import type { TakyonicClient } from '@takyonic/sdk';
+
+// =============================================================================
+// Table Interfaces
+// =============================================================================
+
+${interfaces}
+
+// =============================================================================
+// Type Utilities
+// =============================================================================
+
+/**
+ * Union type of all table names in the schema
+ */
+export type TableName = ${tableNames || 'never'};
+
+/**
+ * Mapping from table names to their interface types
+ */
+export interface TableTypes {
+${tableTypeMap}
+}
+
+/**
+ * Helper type to get the interface type for a table name
+ */
+export type TableType<T extends TableName> = TableTypes[T];
+
+// =============================================================================
+// Usage Examples
+// =============================================================================
+
+/**
+ * Example usage with @takyonic/sdk:
+ * 
+ * \`\`\`typescript
+ * import { TakyonicClient } from '@takyonic/sdk';
+ * import type { ${exampleType} } from './generated';
+ * 
+ * const db = new TakyonicClient({
+ *   endpoint: 'http://localhost:8080',
+ *   token: process.env.TAKYONIC_API_KEY!
+ * });
+ * 
+ * // Type-safe queries
+ * const records = await db.table<${exampleType}>('${exampleName}').get();
+ * 
+ * // Type-safe inserts
+ * await db.table<${exampleType}>('${exampleName}').insert({
+ *   id: 'new-id',
+ *   // ... other fields
+ * });
+ * 
+ * // Type-safe search with filters
+ * const filtered = await db.table<${exampleType}>('${exampleName}')
+ *   .where('id', '=', 'some-id')
+ *   .get();
+ * \`\`\`
+ */
+`;
+
+  return code;
+}

package/src/index.ts

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import dotenv from 'dotenv';
+import { inspectCommand } from './commands/inspect';
+import { initCommand } from './commands/init';
+import { generateCommand } from './commands/generate';
+import { pullCommand } from './commands/pull';
+import { pushCommand } from './commands/push';
+
+// Load environment variables
+dotenv.config();
+
+const program = new Command();
+
+program
+  .name('takyonic-cli')
+  .description('⚡ Takyonic CLI - High-performance Data Framework for PostgreSQL')
+  .version('1.0.0');
+
+program.addCommand(initCommand);
+program.addCommand(generateCommand);
+program.addCommand(pullCommand);
+program.addCommand(pushCommand);
+
+program
+  .command('inspect')
+  .description('Inspect database schema via Takyonic server API')
+  .action(inspectCommand);
+
+program.parse();
+

package/src/parser.ts

@@ -0,0 +1,285 @@
+/**
+ * Takyonic DSL Parser
+ * Parses .takyonic schema files into structured data
+ */
+
+export interface EngineConfig {
+  provider: string;
+  db?: string;
+  cache?: string;
+  port?: number;
+}
+
+export interface TableField {
+  name: string;
+  type: string;
+  decorators: {
+    primary?: boolean;
+    default?: string;
+  };
+}
+
+export interface TableDefinition {
+  name: string;
+  fields: TableField[];
+}
+
+export interface TakyonicSchema {
+  engine: EngineConfig;
+  tables: TableDefinition[];
+}
+
+export class ParseError extends Error {
+  constructor(message: string, public line?: number, public column?: number) {
+    super(message);
+    this.name = 'ParseError';
+  }
+}
+
+/**
+ * Parse a Takyonic DSL file into structured schema
+ */
+export function parseTakyonicSchema(content: string): TakyonicSchema {
+  const lines = content.split('\n');
+  let currentLine = 0;
+  let currentColumn = 0;
+
+  const schema: TakyonicSchema = {
+    engine: { provider: 'takyonic' },
+    tables: [],
+  };
+
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i].trim();
+    currentLine = i + 1;
+
+    // Skip empty lines and comments
+    if (!line || line.startsWith('//')) {
+      i++;
+      continue;
+    }
+
+    // Parse engine block
+    if (line.startsWith('engine')) {
+      const engineEnd = findBlockEnd(lines, i);
+      schema.engine = parseEngineBlock(lines.slice(i, engineEnd + 1));
+      i = engineEnd + 1;
+      continue;
+    }
+
+    // Parse table definitions
+    if (line.startsWith('table')) {
+      const tableEnd = findBlockEnd(lines, i);
+      const table = parseTableBlock(lines.slice(i, tableEnd + 1));
+      schema.tables.push(table);
+      i = tableEnd + 1;
+      continue;
+    }
+
+    i++;
+  }
+
+  // Validate engine has provider
+  if (!schema.engine.provider) {
+    throw new ParseError('Engine block must specify provider', currentLine);
+  }
+
+  if (schema.engine.provider !== 'takyonic') {
+    throw new ParseError('Provider must be "takyonic"', currentLine);
+  }
+
+  return schema;
+}
+
+/**
+ * Find the closing brace for a block starting at startLine
+ */
+function findBlockEnd(lines: string[], startLine: number): number {
+  let depth = 0;
+  let foundOpen = false;
+
+  for (let i = startLine; i < lines.length; i++) {
+    const line = lines[i];
+    for (let j = 0; j < line.length; j++) {
+      if (line[j] === '{') {
+        depth++;
+        foundOpen = true;
+      } else if (line[j] === '}') {
+        depth--;
+        if (foundOpen && depth === 0) {
+          return i;
+        }
+      }
+    }
+  }
+
+  throw new ParseError('Unclosed block', startLine + 1);
+}
+
+/**
+ * Parse engine block
+ */
+function parseEngineBlock(lines: string[]): EngineConfig {
+  const config: EngineConfig = { provider: 'takyonic' };
+  const content = lines.join('\n');
+
+  // Extract provider
+  const providerMatch = content.match(/provider\s*=\s*"([^"]+)"/);
+  if (providerMatch) {
+    config.provider = providerMatch[1];
+  }
+
+  // Extract db
+  const dbMatch = content.match(/db\s*=\s*(env\([^)]+\)|"[^"]+")/);
+  if (dbMatch) {
+    config.db = dbMatch[1];
+  }
+
+  // Extract cache
+  const cacheMatch = content.match(/cache\s*=\s*"([^"]+)"/);
+  if (cacheMatch) {
+    config.cache = cacheMatch[1];
+  }
+
+  // Extract port
+  const portMatch = content.match(/port\s*=\s*(\d+)/);
+  if (portMatch) {
+    config.port = parseInt(portMatch[1], 10);
+  }
+
+  return config;
+}
+
+/**
+ * Parse table block
+ */
+function parseTableBlock(lines: string[]): TableDefinition {
+  // Extract table name from first line
+  const firstLine = lines[0].trim();
+  const tableNameMatch = firstLine.match(/table\s+(\w+)\s*\{/);
+  if (!tableNameMatch) {
+    throw new ParseError('Invalid table definition', 1);
+  }
+
+  const tableName = tableNameMatch[1];
+  const fields: TableField[] = [];
+
+  // Parse field definitions (skip first and last lines which are table declaration and closing brace)
+  for (let i = 1; i < lines.length - 1; i++) {
+    const line = lines[i].trim();
+    
+    // Skip empty lines and comments
+    if (!line || line.startsWith('//')) {
+      continue;
+    }
+
+    const field = parseFieldLine(line);
+    if (field) {
+      fields.push(field);
+    }
+  }
+
+  return {
+    name: tableName,
+    fields,
+  };
+}
+
+/**
+ * Parse a single field line
+ * Supports both formats:
+ * - Space syntax: "id    string  @primary"
+ * - Colon syntax: "id: string @primary"
+ * Example: "price int     @default(now())"
+ */
+function parseFieldLine(line: string): TableField | null {
+  // Remove comments
+  const cleanLine = line.split('//')[0].trim();
+  if (!cleanLine) {
+    return null;
+  }
+
+  // Extract decorators first (they start with @)
+  const decorators: TableField['decorators'] = {};
+  const decoratorPattern = /@(\w+)/g;
+  let decoratorMatch;
+  
+  while ((decoratorMatch = decoratorPattern.exec(cleanLine)) !== null) {
+    const decoratorName = decoratorMatch[1];
+    const decoratorStart = decoratorMatch.index + decoratorMatch[0].length;
+    
+    if (decoratorName === 'primary') {
+      decorators.primary = true;
+    } else if (decoratorName === 'default') {
+      // Extract the value with balanced parentheses
+      const valueStart = cleanLine.indexOf('(', decoratorStart);
+      if (valueStart !== -1) {
+        const value = extractBalancedParens(cleanLine, valueStart);
+        if (value) {
+          // Remove outer quotes if present
+          decorators.default = value.replace(/^["']|["']$/g, '');
+        }
+      }
+    }
+  }
+
+  // Remove all decorators from the line to parse name and type
+  const lineWithoutDecorators = cleanLine.replace(/@\w+(\([^)]*\)|\(.*?\)\))?/g, '').trim();
+  
+  // Handle both "name: type" and "name type" formats
+  let name: string;
+  let type: string;
+  
+  if (lineWithoutDecorators.includes(':')) {
+    // Colon syntax: "id: string" or "id : string"
+    const colonParts = lineWithoutDecorators.split(':').map(p => p.trim());
+    if (colonParts.length < 2 || !colonParts[0] || !colonParts[1]) {
+      return null;
+    }
+    name = colonParts[0];
+    type = colonParts[1].split(/\s+/)[0]; // Take first word after colon as type
+  } else {
+    // Space syntax: "id string"
+    const parts = lineWithoutDecorators.split(/\s+/);
+    if (parts.length < 2) {
+      return null;
+    }
+    name = parts[0];
+    type = parts[1];
+  }
+
+  return {
+    name,
+    type,
+    decorators,
+  };
+}
+
+/**
+ * Extract content within balanced parentheses
+ * For input "@default(now())" starting at '(' position, returns "now()"
+ */
+function extractBalancedParens(str: string, startPos: number): string | null {
+  if (str[startPos] !== '(') {
+    return null;
+  }
+  
+  let depth = 0;
+  let start = startPos + 1;
+  
+  for (let i = startPos; i < str.length; i++) {
+    if (str[i] === '(') {
+      depth++;
+    } else if (str[i] === ')') {
+      depth--;
+      if (depth === 0) {
+        return str.substring(start, i);
+      }
+    }
+  }
+  
+  // Unbalanced parentheses - return what we have
+  return str.substring(start);
+}
+

package/src/test-bulk.ts

@@ -0,0 +1,38 @@
+import axios from 'axios';
+
+const TOTAL_RECORDS = 10000;
+const BATCH_SIZE = 1000; // Her istekte 1000 kayıt
+
+async function runBulkTest() {
+    console.log(`🚀 Takyonic BULK Test: Sending ${TOTAL_RECORDS} records in batches of ${BATCH_SIZE}...`);
+    const startTime = Date.now();
+
+    for (let i = 0; i < TOTAL_RECORDS; i += BATCH_SIZE) {
+        const batch = Array.from({ length: BATCH_SIZE }).map((_, j) => ({
+            id: `B-${i + j}`,
+            event: 'bulk_test_event',
+            payload: { value: Math.random(), batch_group: i / BATCH_SIZE },
+            severity: Math.floor(Math.random() * 5) + 1
+        }));
+
+        try {
+            await axios.post(`http://localhost:8080/v1/bulk-write/logs`, batch, {
+                headers: { 'Authorization': 'Bearer takyonic_admin_secret' }
+            });
+            console.log(`✅ Sent batch starting at ${i}...`);
+        } catch (error) {
+            if (axios.isAxiosError(error)) {
+                console.error(`❌ Error at batch ${i}:`, error.response?.data || error.message);
+            } else if (error instanceof Error) {
+                console.error(`❌ Error at batch ${i}:`, error.message);
+            } else {
+                console.error(`❌ Error at batch ${i}:`, String(error));
+            }
+        }
+    }
+
+    const duration = (Date.now() - startTime) / 1000;
+    console.log(`🏁 Bulk test completed in ${duration} seconds!`);
+}
+
+runBulkTest();

package/src/test-load.ts

@@ -0,0 +1,28 @@
+import axios from 'axios';
+
+const TOTAL_RECORDS = 10000;
+const BATCH_SIZE = 100; // 100'erli gruplar halinde gönderelim
+
+async function runLoadTest() {
+    console.log(`⚡ Takyonic Load Test: Sending ${TOTAL_RECORDS} logs...`);
+    
+    for (let i = 0; i < TOTAL_RECORDS; i += BATCH_SIZE) {
+        const promises = Array.from({ length: BATCH_SIZE }).map((_, j) => {
+            const id = `L-${i + j}`;
+            return axios.post('http://localhost:8080/v1/write/logs', {
+                id,
+                event: 'load_test_event',
+                payload: { value: Math.random(), batch: i },
+                severity: Math.floor(Math.random() * 5)
+            }, {
+                headers: { 'Authorization': 'Bearer takyonic_admin_secret' }
+            });
+        });
+
+        await Promise.all(promises);
+        if (i % 1000 === 0) console.log(`✅ Sent ${i} records...`);
+    }
+    console.log('🏁 Load test completed!');
+}
+
+runLoadTest();