@promakeai/cli 0.0.5 → 0.0.6

package/template/src/modules/db/adapters/SqliteAdapter.ts

@@ -1,364 +0,0 @@
-import initSqlJs, { Database } from "sql.js";
-import type { IDataAdapter } from "./IDataAdapter";
-import type {
-  QueryOptions,
-  WhereCondition,
-  WhereGroup,
-  JoinClause,
-} from "../core/types";
-
-/**
- * SQLite Adapter
- * Loads database from file using sql.js
- * Supports complex queries: JOIN, WHERE groups, LIKE, IN, BETWEEN
- */
-export class SqliteAdapter implements IDataAdapter {
-  private db: Database | null = null;
-  private dbPath: string;
-
-  constructor(dbPath: string = "/data/database.db") {
-    this.dbPath = dbPath;
-  }
-
-  // ============================================
-  // CONNECTION
-  // ============================================
-
-  async connect(): Promise<void> {
-    if (this.db) return;
-
-    try {
-      const SQL = await initSqlJs({
-        locateFile: (file: string) => `https://sql.js.org/dist/${file}`,
-      });
-
-      const response = await fetch(this.dbPath);
-      if (!response.ok) {
-        throw new Error(`Database file not found: ${this.dbPath}`);
-      }
-
-      const buffer = await response.arrayBuffer();
-      this.db = new SQL.Database(new Uint8Array(buffer));
-      console.log("SQLite adapter connected");
-    } catch (error) {
-      console.error("SQLite adapter connection failed:", error);
-      throw error;
-    }
-  }
-
-  async disconnect(): Promise<void> {
-    if (this.db) {
-      this.db.close();
-      this.db = null;
-    }
-  }
-
-  // ============================================
-  // CRUD OPERATIONS
-  // ============================================
-
-  async findMany<T>(table: string, options?: QueryOptions): Promise<T[]> {
-    await this.connect();
-    if (!this.db) {
-      console.warn("Database not connected");
-      return [];
-    }
-    try {
-      const { sql, params } = this.buildSelectQuery(table, options);
-      return this.executeQuery<T>(sql, params);
-    } catch (error) {
-      console.error(`Error querying table ${table}:`, error);
-      return [];
-    }
-  }
-
-  async findOne<T>(table: string, options: QueryOptions): Promise<T | null> {
-    const results = await this.findMany<T>(table, { ...options, limit: 1 });
-    return results[0] || null;
-  }
-
-  async findById<T>(table: string, id: number | string): Promise<T | null> {
-    return this.findOne<T>(table, { where: { id } });
-  }
-
-  async create<T>(table: string, data: Partial<T>): Promise<T> {
-    await this.connect();
-
-    // Otomatik timestamp - sadece yoksa ekle
-    const dataWithTimestamps: any = { ...data };
-
-    if (!dataWithTimestamps.created_at) {
-      dataWithTimestamps.created_at = new Date().toISOString();
-    }
-
-    if (!dataWithTimestamps.updated_at) {
-      dataWithTimestamps.updated_at = new Date().toISOString();
-    }
-
-    const keys = Object.keys(dataWithTimestamps);
-    const values = Object.values(dataWithTimestamps) as any[];
-    const placeholders = keys.map(() => "?").join(", ");
-
-    const sql = `INSERT INTO ${table} (${keys.join(", ")}) VALUES (${placeholders})`;
-    this.db!.run(sql, values);
-
-    const lastIdResult = this.db!.exec("SELECT last_insert_rowid() as id");
-    const lastId = lastIdResult[0]?.values[0]?.[0] as number;
-
-    return this.findById<T>(table, lastId) as Promise<T>;
-  }
-
-  async update<T>(
-    table: string,
-    id: number | string,
-    data: Partial<T>,
-  ): Promise<T> {
-    await this.connect();
-
-    // Otomatik updated_at - her zaman güncelle
-    const dataWithTimestamp = {
-      ...data,
-      updated_at: new Date().toISOString(),
-    };
-
-    const keys = Object.keys(dataWithTimestamp);
-    const values = Object.values(dataWithTimestamp) as any[];
-    const setClause = keys.map((key) => `${key} = ?`).join(", ");
-
-    const sql = `UPDATE ${table} SET ${setClause} WHERE id = ?`;
-    this.db!.run(sql, [...values, id]);
-
-    return this.findById<T>(table, id) as Promise<T>;
-  }
-
-  async delete(table: string, id: number | string): Promise<boolean> {
-    await this.connect();
-    const sql = `DELETE FROM ${table} WHERE id = ?`;
-    this.db!.run(sql, [id]);
-    return true;
-  }
-
-  async count(table: string, options?: QueryOptions): Promise<number> {
-    await this.connect();
-    const { sql, params } = this.buildCountQuery(table, options);
-    const results = await this.executeQuery<{ count: number }>(sql, params);
-    return results[0]?.count || 0;
-  }
-
-  // ============================================
-  // RAW SQL QUERIES
-  // ============================================
-
-  async raw<T>(sql: string, params?: any[]): Promise<T[]> {
-    await this.connect();
-    return this.executeQuery<T>(sql, params);
-  }
-
-  async rawOne<T>(sql: string, params?: any[]): Promise<T | null> {
-    const results = await this.raw<T>(sql, params);
-    return results[0] || null;
-  }
-
-  // ============================================
-  // PRIVATE: QUERY EXECUTION
-  // ============================================
-
-  private async executeQuery<T>(sql: string, params?: any[]): Promise<T[]> {
-    if (!this.db) {
-      console.warn("Database not connected");
-      return [];
-    }
-    try {
-      const stmt = this.db.prepare(sql);
-      if (params && params.length > 0) stmt.bind(params);
-
-      const results: T[] = [];
-      while (stmt.step()) {
-        results.push(stmt.getAsObject() as T);
-      }
-      stmt.free();
-      return results;
-    } catch (error) {
-      console.error(`Query error: ${sql}`, error);
-      return [];
-    }
-  }
-
-  // ============================================
-  // PRIVATE: QUERY BUILDERS
-  // ============================================
-
-  private buildSelectQuery(
-    table: string,
-    options?: QueryOptions,
-  ): { sql: string; params: any[] } {
-    const params: any[] = [];
-
-    // SELECT clause
-    const selectFields = options?.select?.join(", ") || "*";
-    const distinct = options?.distinct ? "DISTINCT " : "";
-    let sql = `SELECT ${distinct}${selectFields} FROM ${table}`;
-
-    // JOIN clauses
-    if (options?.joins && options.joins.length > 0) {
-      sql += this.buildJoinClause(options.joins);
-    }
-
-    // WHERE clause
-    const whereClause = this.buildWhereClause(options, params);
-    if (whereClause) {
-      sql += ` WHERE ${whereClause}`;
-    }
-
-    // GROUP BY clause
-    if (options?.groupBy && options.groupBy.length > 0) {
-      sql += ` GROUP BY ${options.groupBy.join(", ")}`;
-    }
-
-    // HAVING clause
-    if (options?.having) {
-      const havingClause = this.buildWhereGroupClause(options.having, params);
-      if (havingClause) {
-        sql += ` HAVING ${havingClause}`;
-      }
-    }
-
-    // ORDER BY clause
-    if (options?.orderBy && options.orderBy.length > 0) {
-      const orderClauses = options.orderBy.map(
-        (o) => `${o.field} ${o.direction}`,
-      );
-      sql += ` ORDER BY ${orderClauses.join(", ")}`;
-    }
-
-    // LIMIT & OFFSET
-    if (options?.limit) {
-      sql += ` LIMIT ?`;
-      params.push(options.limit);
-    }
-
-    if (options?.offset) {
-      sql += ` OFFSET ?`;
-      params.push(options.offset);
-    }
-
-    return { sql, params };
-  }
-
-  private buildCountQuery(
-    table: string,
-    options?: QueryOptions,
-  ): { sql: string; params: any[] } {
-    const params: any[] = [];
-    let sql = `SELECT COUNT(*) as count FROM ${table}`;
-
-    // JOIN clauses
-    if (options?.joins && options.joins.length > 0) {
-      sql += this.buildJoinClause(options.joins);
-    }
-
-    // WHERE clause
-    const whereClause = this.buildWhereClause(options, params);
-    if (whereClause) {
-      sql += ` WHERE ${whereClause}`;
-    }
-
-    return { sql, params };
-  }
-
-  private buildJoinClause(joins: JoinClause[]): string {
-    return joins
-      .map((join) => {
-        const alias = join.alias ? ` ${join.alias}` : "";
-        const leftField = join.on.leftField;
-        const rightField = join.on.rightField;
-        return ` ${join.type} JOIN ${join.table}${alias} ON ${leftField} = ${rightField}`;
-      })
-      .join("");
-  }
-
-  private buildWhereClause(
-    options: QueryOptions | undefined,
-    params: any[],
-  ): string {
-    const clauses: string[] = [];
-
-    // Simple where (backwards compatible)
-    if (options?.where) {
-      const simpleConditions = Object.entries(options.where).map(
-        ([key, value]) => {
-          params.push(value);
-          return `${key} = ?`;
-        },
-      );
-      if (simpleConditions.length > 0) {
-        clauses.push(simpleConditions.join(" AND "));
-      }
-    }
-
-    // Advanced where (new feature)
-    if (options?.whereAdvanced) {
-      const advancedClause = this.buildWhereGroupClause(
-        options.whereAdvanced,
-        params,
-      );
-      if (advancedClause) {
-        clauses.push(advancedClause);
-      }
-    }
-
-    return clauses.length > 0 ? clauses.join(" AND ") : "";
-  }
-
-  private buildWhereGroupClause(group: WhereGroup, params: any[]): string {
-    const conditions = group.conditions
-      .map((condition) => {
-        // Recursive: WhereGroup
-        if ("type" in condition && "conditions" in condition) {
-          return `(${this.buildWhereGroupClause(condition as WhereGroup, params)})`;
-        }
-        // WhereCondition
-        return this.buildConditionClause(condition as WhereCondition, params);
-      })
-      .filter(Boolean);
-
-    return conditions.join(` ${group.type} `);
-  }
-
-  private buildConditionClause(
-    condition: WhereCondition,
-    params: any[],
-  ): string {
-    const { field, operator, value } = condition;
-
-    switch (operator) {
-      case "IS NULL":
-        return `${field} IS NULL`;
-
-      case "IS NOT NULL":
-        return `${field} IS NOT NULL`;
-
-      case "IN":
-      case "NOT IN":
-        if (Array.isArray(value)) {
-          const placeholders = value.map(() => "?").join(", ");
-          params.push(...value);
-          return `${field} ${operator} (${placeholders})`;
-        }
-        return "";
-
-      case "BETWEEN":
-      case "NOT BETWEEN":
-        if (Array.isArray(value) && value.length === 2) {
-          params.push(value[0], value[1]);
-          return `${field} ${operator} ? AND ?`;
-        }
-        return "";
-
-      default:
-        // =, !=, <>, >, <, >=, <=, LIKE, NOT LIKE
-        params.push(value);
-        return `${field} ${operator} ?`;
-    }
-  }
-}

package/template/src/modules/db/adapters/index.ts

@@ -1,2 +0,0 @@
-export type { IDataAdapter } from "./IDataAdapter";
-export { SqliteAdapter } from "./SqliteAdapter";

package/template/src/modules/db/config.ts

@@ -1,59 +0,0 @@
-import type { IDataAdapter } from "./adapters/IDataAdapter";
-import { SqliteAdapter } from "./adapters/SqliteAdapter";
-
-export type AdapterType = "sqlite";
-
-export interface DataConfig {
-  adapter: AdapterType;
-  options?: {
-    dbPath?: string;
-  };
-}
-
-/**
- * Get configuration from environment variables
- */
-function getConfig(): DataConfig {
-  const adapter =
-    (import.meta.env.VITE_DATA_ADAPTER as AdapterType) || "sqlite";
-
-  return {
-    adapter,
-    options: {
-      dbPath: import.meta.env.VITE_DB_PATH || "/data/database.db",
-    },
-  };
-}
-
-/**
- * Create adapter instance based on configuration
- */
-export function createAdapter(config: DataConfig): IDataAdapter {
-  switch (config.adapter) {
-    case "sqlite":
-      return new SqliteAdapter(config.options?.dbPath);
-
-    default:
-      throw new Error(`Unknown adapter: ${config.adapter}`);
-  }
-}
-
-/**
- * Get the configured adapter instance (singleton)
- */
-let adapterInstance: IDataAdapter | null = null;
-
-export function getAdapter(): IDataAdapter {
-  if (!adapterInstance) {
-    const config = getConfig();
-    adapterInstance = createAdapter(config);
-  }
-  return adapterInstance;
-}
-
-/**
- * Reset adapter instance (useful for testing or switching adapters)
- */
-export function resetAdapter(): void {
-  adapterInstance = null;
-}

package/template/src/modules/db/core/DataManager.ts

@@ -1,125 +0,0 @@
-import type { IDataAdapter } from "../adapters/IDataAdapter";
-import type { QueryOptions, PaginatedResult } from "./types";
-
-/**
- * DataManager - Simple proxy to adapter
- */
-export class DataManager {
-  private static instance: DataManager;
-  private adapter: IDataAdapter;
-
-  private constructor(adapter: IDataAdapter) {
-    this.adapter = adapter;
-  }
-
-  static getInstance(adapter: IDataAdapter): DataManager {
-    if (!DataManager.instance) {
-      DataManager.instance = new DataManager(adapter);
-    }
-    return DataManager.instance;
-  }
-
-  // Simple pass-through methods - no cache logic
-  async query<T = any>(table: string, options?: QueryOptions): Promise<T[]> {
-    return this.adapter.findMany<T>(table, options);
-  }
-
-  async queryOne<T = any>(
-    table: string,
-    options?: QueryOptions,
-  ): Promise<T | null> {
-    const results = await this.query<T>(table, { ...options, limit: 1 });
-    return results[0] || null;
-  }
-
-  async queryById<T = any>(
-    table: string,
-    id: number | string,
-  ): Promise<T | null> {
-    return this.adapter.findById<T>(table, id);
-  }
-
-  async count(table: string, options?: QueryOptions): Promise<number> {
-    return this.adapter.count(table, options);
-  }
-
-  async paginate<T = any>(
-    table: string,
-    page: number = 1,
-    limit: number = 10,
-    options?: QueryOptions,
-  ): Promise<PaginatedResult<T>> {
-    const offset = (page - 1) * limit;
-
-    const [data, total] = await Promise.all([
-      this.query<T>(table, { ...options, limit, offset }),
-      this.count(table, options),
-    ]);
-
-    return {
-      data,
-      page,
-      limit,
-      total,
-      totalPages: Math.ceil(total / limit),
-      hasMore: page * limit < total,
-    };
-  }
-
-  // Mutations - no cache invalidation here (React Query handles it)
-  async create<T = any>(table: string, data: Partial<T>): Promise<T> {
-    return this.adapter.create<T>(table, data);
-  }
-
-  async update<T = any>(
-    table: string,
-    id: number | string,
-    data: Partial<T>,
-  ): Promise<T> {
-    return this.adapter.update<T>(table, id, data);
-  }
-
-  async delete(table: string, id: number | string): Promise<boolean> {
-    return this.adapter.delete(table, id);
-  }
-
-  // Direct adapter access for advanced use cases
-  getAdapter(): IDataAdapter {
-    return this.adapter;
-  }
-
-  // ============================================
-  // RAW SQL QUERIES
-  // ============================================
-
-  /**
-   * Execute raw SQL query - returns multiple rows
-   * Use for complex queries that can't be expressed with QueryOptions
-   *
-   * @example
-   * const posts = await dm.raw<Post>(`
-   *   SELECT DISTINCT p.*, c.name as category_name
-   *   FROM posts p
-   *   JOIN post_categories pc ON p.id = pc.post_id
-   *   JOIN blog_categories c ON pc.category_id = c.id
-   *   WHERE c.slug = ? AND p.published = 1
-   * `, [categorySlug]);
-   */
-  async raw<T = any>(sql: string, params?: any[]): Promise<T[]> {
-    return this.adapter.raw<T>(sql, params);
-  }
-
-  /**
-   * Execute raw SQL query - returns single row or null
-   * Use for aggregations, single record lookups
-   *
-   * @example
-   * const priceRange = await dm.rawOne<{min: number, max: number}>(`
-   *   SELECT MIN(price) as min, MAX(price) as max
-   *   FROM products WHERE published = 1
-   * `);
-   */
-  async rawOne<T = any>(sql: string, params?: any[]): Promise<T | null> {
-    return this.adapter.rawOne<T>(sql, params);
-  }
-}

package/template/src/modules/db/core/types.ts

@@ -1,101 +0,0 @@
-/**
- * Core type definitions for data-access module
- */
-
-// ============================================
-// WHERE CONDITIONS
-// ============================================
-
-/** WHERE condition operators */
-export type WhereOperator =
-  | "="
-  | "!="
-  | "<>"
-  | ">"
-  | "<"
-  | ">="
-  | "<="
-  | "LIKE"
-  | "NOT LIKE"
-  | "IN"
-  | "NOT IN"
-  | "BETWEEN"
-  | "NOT BETWEEN"
-  | "IS NULL"
-  | "IS NOT NULL";
-
-/** Single WHERE condition */
-export interface WhereCondition {
-  field: string;
-  operator: WhereOperator;
-  value: any;
-}
-
-/** WHERE groups (AND/OR) - recursive structure */
-export interface WhereGroup {
-  type: "AND" | "OR";
-  conditions: (WhereCondition | WhereGroup)[];
-}
-
-// ============================================
-// JOIN DEFINITIONS
-// ============================================
-
-/** JOIN types */
-export type JoinType = "INNER" | "LEFT" | "RIGHT" | "CROSS";
-
-/** JOIN definition */
-export interface JoinClause {
-  type: JoinType;
-  table: string;
-  alias?: string;
-  on: {
-    leftField: string;
-    rightField: string;
-  };
-}
-
-// ============================================
-// QUERY OPTIONS
-// ============================================
-
-/** Order definition */
-export interface OrderBy {
-  field: string;
-  direction: "ASC" | "DESC";
-}
-
-/** Extended Query Options */
-export interface QueryOptions {
-  // Existing (backwards compatible)
-  where?: Record<string, any>;
-  limit?: number;
-  offset?: number;
-  orderBy?: OrderBy[];
-  include?: string[];
-
-  // New features
-  select?: string[]; // SELECT fields: ['p.*', 'c.name as category_name']
-  distinct?: boolean; // DISTINCT usage
-  joins?: JoinClause[]; // JOIN definitions
-  whereAdvanced?: WhereGroup; // Complex WHERE conditions (AND/OR groups)
-  groupBy?: string[]; // GROUP BY fields
-  having?: WhereGroup; // HAVING conditions
-}
-
-// ============================================
-// RESULT TYPES
-// ============================================
-
-/** Paginated result */
-export interface PaginatedResult<T> {
-  data: T[];
-  page: number;
-  limit: number;
-  total: number;
-  totalPages: number;
-  hasMore: boolean;
-}
-
-/** Query key (for cache) */
-export type QueryKey = (string | number | object)[];

package/template/src/modules/db/index.ts

@@ -1,42 +0,0 @@
-/**
- * DB Module
- * Universal data management with adapter pattern + React Query
- */
-
-// Core
-export { DataManager } from "./core/DataManager";
-export type {
-  QueryOptions,
-  OrderBy,
-  PaginatedResult,
-  // Complex query types
-  WhereOperator,
-  WhereCondition,
-  WhereGroup,
-  JoinType,
-  JoinClause,
-} from "./core/types";
-
-// Adapters
-export type { IDataAdapter } from "./adapters/IDataAdapter";
-export { SqliteAdapter } from "./adapters/SqliteAdapter";
-
-// Config
-export { getAdapter, createAdapter, resetAdapter } from "./config";
-export type { DataConfig, AdapterType } from "./config";
-
-// React exports (re-export from react/index.ts)
-export * from "./react";
-
-// Re-export for convenience
-export { DBQueryProvider as QueryProvider } from "./react";
-
-// Utility exports (parsers for client-side data transformation)
-export {
-  parseCommaSeparatedString,
-  parseJSONStringToArray,
-  parseStringToArray,
-  parseJSONString,
-  parseSQLiteBoolean,
-  parseNumberSafe,
-} from "./utils/parsers";

package/template/src/modules/db/react/QueryProvider.tsx

@@ -1,16 +0,0 @@
-import { QueryClientProvider } from "@tanstack/react-query";
-import { queryClient } from "./queryClient";
-
-interface DBQueryProviderProps {
-  children: React.ReactNode;
-}
-
-/**
- * DBQueryProvider - DB module's React Query provider
- * Wraps components that use db module hooks
- */
-export function DBQueryProvider({ children }: DBQueryProviderProps) {
-  return (
-    <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
-  );
-}