@promakeai/cli 0.0.5 → 0.0.6

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

@@ -1,23 +0,0 @@
-// Provider
-export { DBQueryProvider } from "./QueryProvider";
-
-// Query client and utilities
-export { queryClient, queryKeys, cacheUtils } from "./queryClient";
-
-// Generic repository hooks
-export {
-  useRepositoryQuery,
-  useRepositoryQueryOne,
-  useRepositoryQueryById,
-  useRepositoryPagination,
-  useRepositoryInfiniteQuery,
-  useRepositoryCreate,
-  useRepositoryUpdate,
-  useRepositoryDelete,
-  // Raw SQL hooks
-  useRawQuery,
-  useRawQueryOne,
-} from "./useRepository";
-
-// Types
-export type { RepositoryQueryOptions } from "./useRepository";

package/template/src/modules/db/react/queryClient.ts

@@ -1,64 +0,0 @@
-import { QueryClient } from "@tanstack/react-query";
-
-/**
- * React Query handles ALL caching, refetching, and invalidation
- * No custom cache needed!
- */
-export const queryClient = new QueryClient({
-  defaultOptions: {
-    queries: {
-      staleTime: 30 * 1000, // 30 seconds fresh
-      gcTime: 5 * 60 * 1000, // 5 minutes in cache (was cacheTime)
-      retry: 1,
-      refetchOnWindowFocus: false, // Don't auto-refetch on window focus
-      refetchOnReconnect: false, // Don't refetch on reconnect
-      refetchOnMount: false, // Don't refetch on component mount (prevent loops)
-    },
-    mutations: {
-      retry: 0,
-    },
-  },
-});
-
-/**
- * Query key factory - for cache management
- * React Query uses these keys to cache and invalidate queries
- */
-export const queryKeys = {
-  all: (table: string) => [table] as const,
-  lists: (table: string) => [table, "list"] as const,
-  list: (table: string, options?: any) => [table, "list", options] as const,
-  details: (table: string) => [table, "detail"] as const,
-  detail: (table: string, id: number | string) =>
-    [table, "detail", id] as const,
-  paginated: (table: string, page: number, limit: number, options?: any) =>
-    [table, "paginated", page, limit, options] as const,
-  infinite: (table: string, limit: number, options?: any) =>
-    [table, "infinite", limit, options] as const,
-  count: (table: string, options?: any) => [table, "count", options] as const,
-};
-
-/**
- * Manual cache utilities (rarely needed)
- */
-export const cacheUtils = {
-  // Invalidate all queries for a table
-  invalidateTable: (table: string) => {
-    return queryClient.invalidateQueries({ queryKey: queryKeys.all(table) });
-  },
-
-  // Clear all cache
-  clearAll: () => {
-    return queryClient.clear();
-  },
-
-  // Get cached data
-  getCachedData: <T>(queryKey: any[]) => {
-    return queryClient.getQueryData<T>(queryKey);
-  },
-
-  // Set cached data manually
-  setCachedData: <T>(queryKey: any[], data: T) => {
-    return queryClient.setQueryData<T>(queryKey, data);
-  },
-};

package/template/src/modules/db/react/useRepository.ts

@@ -1,400 +0,0 @@
-import {
-  useQuery,
-  useMutation,
-  useQueryClient,
-  useInfiniteQuery,
-  type UseQueryOptions,
-  type UseMutationOptions,
-  type UseInfiniteQueryOptions,
-} from "@tanstack/react-query";
-import { DataManager } from "../core/DataManager";
-import { getAdapter } from "../config";
-import { queryKeys } from "./queryClient";
-import type { QueryOptions } from "../core/types";
-
-// Singleton manager
-let managerInstance: DataManager | null = null;
-function getManager() {
-  if (!managerInstance) {
-    managerInstance = DataManager.getInstance(getAdapter());
-  }
-  return managerInstance;
-}
-
-// ==========================================
-// QUERY HOOKS
-// ==========================================
-
-// Omit 'select' from QueryOptions to avoid conflict with React Query's select
-export interface RepositoryQueryOptions<T> extends Omit<
-  QueryOptions,
-  "select"
-> {
-  // SQL SELECT fields (renamed to avoid conflict)
-  selectFields?: string[];
-
-  // React Query options
-  enabled?: boolean;
-  staleTime?: number;
-  gcTime?: number;
-  refetchOnWindowFocus?: boolean;
-  refetchInterval?: number | false;
-  select?: (data: T[]) => any; // React Query data transformation
-}
-
-/**
- * Generic query hook - React Query handles all caching
- * @example
- * // Simple query
- * const { data: posts, isLoading } = useRepositoryQuery('posts', {
- *   where: { published: 1 },
- *   orderBy: [{ field: 'created_at', direction: 'DESC' }],
- *   staleTime: 60000
- * });
- *
- * // With JOIN
- * const { data: posts } = useRepositoryQuery('posts', {
- *   selectFields: ['posts.*', 'c.name as category_name'],
- *   joins: [{
- *     type: 'INNER',
- *     table: 'post_categories',
- *     alias: 'pc',
- *     on: { leftField: 'posts.id', rightField: 'pc.post_id' }
- *   }],
- *   distinct: true
- * });
- *
- * // With complex WHERE
- * const { data: products } = useRepositoryQuery('products', {
- *   whereAdvanced: {
- *     type: 'AND',
- *     conditions: [
- *       { field: 'published', operator: '=', value: 1 },
- *       { type: 'OR', conditions: [
- *         { field: 'name', operator: 'LIKE', value: '%phone%' },
- *         { field: 'description', operator: 'LIKE', value: '%phone%' }
- *       ]}
- *     ]
- *   }
- * });
- */
-export function useRepositoryQuery<T = any>(
-  table: string,
-  options: RepositoryQueryOptions<T> = {},
-  queryOptions?: Omit<UseQueryOptions<T[], Error>, "queryKey" | "queryFn">,
-) {
-  const manager = getManager();
-  const {
-    // QueryOptions fields
-    where,
-    limit,
-    offset,
-    orderBy,
-    include,
-    // New complex query fields
-    selectFields,
-    distinct,
-    joins,
-    whereAdvanced,
-    groupBy,
-    having,
-    // React Query options
-    select,
-    enabled,
-    staleTime,
-    gcTime,
-    refetchOnWindowFocus,
-    refetchInterval,
-  } = options;
-
-  const queryOpts: QueryOptions = {
-    where,
-    limit,
-    offset,
-    orderBy,
-    include,
-    select: selectFields,
-    distinct,
-    joins,
-    whereAdvanced,
-    groupBy,
-    having,
-  };
-
-  return useQuery<T[], Error>({
-    queryKey: queryKeys.list(table, queryOpts),
-    queryFn: () => manager.query<T>(table, queryOpts),
-    select,
-    enabled,
-    staleTime,
-    gcTime,
-    refetchOnWindowFocus,
-    refetchInterval,
-    ...queryOptions,
-  });
-}
-
-/**
- * Query single record
- * @example
- * const { data: post } = useRepositoryQueryOne('posts', {
- *   where: { slug: 'my-post' }
- * });
- */
-export function useRepositoryQueryOne<T = any>(
-  table: string,
-  options: RepositoryQueryOptions<T> = {},
-) {
-  const result = useRepositoryQuery<T>(table, { ...options, limit: 1 });
-
-  return {
-    ...result,
-    data: result.data?.[0] || null,
-  };
-}
-
-/**
- * Query by ID - React Query caches by ID automatically
- * @example
- * const { data: post, isLoading } = useRepositoryQueryById('posts', postId);
- */
-export function useRepositoryQueryById<T = any>(
-  table: string,
-  id: number | string | null | undefined,
-  options: Omit<UseQueryOptions<T | null, Error>, "queryKey" | "queryFn"> = {},
-) {
-  const manager = getManager();
-
-  return useQuery<T | null, Error>({
-    queryKey: queryKeys.detail(table, id as any),
-    queryFn: () => manager.queryById<T>(table, id as any),
-    enabled: options.enabled !== false && id != null,
-    ...options,
-  });
-}
-
-/**
- * Paginated query - React Query caches each page
- * @example
- * const { data, totalPages, hasMore } = useRepositoryPagination('products', page, 20);
- */
-export function useRepositoryPagination<T = any>(
-  table: string,
-  page: number = 1,
-  limit: number = 10,
-  options: QueryOptions = {},
-) {
-  const manager = getManager();
-
-  return useQuery({
-    queryKey: queryKeys.paginated(table, page, limit, options),
-    queryFn: () => manager.paginate<T>(table, page, limit, options),
-  });
-}
-
-/**
- * Infinite query for infinite scroll / load more
- * @example
- * const { data, fetchNextPage, hasNextPage, isFetchingNextPage } =
- *   useRepositoryInfiniteQuery('posts', 20, {
- *     where: { published: 1 },
- *     orderBy: [{ field: 'created_at', direction: 'DESC' }]
- *   });
- *
- * // data.pages = [page1Data, page2Data, page3Data, ...]
- * const allPosts = data?.pages.flatMap(page => page.data) ?? [];
- */
-export function useRepositoryInfiniteQuery<T = any>(
-  table: string,
-  pageSize: number = 20,
-  options: QueryOptions = {},
-  queryOptions?: Omit<
-    UseInfiniteQueryOptions<
-      { data: T[]; page: number; totalPages: number; hasMore: boolean },
-      Error
-    >,
-    "queryKey" | "queryFn" | "getNextPageParam" | "initialPageParam"
-  >,
-) {
-  const manager = getManager();
-
-  return useInfiniteQuery({
-    queryKey: queryKeys.infinite(table, pageSize, options),
-    queryFn: ({ pageParam }) =>
-      manager.paginate<T>(table, pageParam as number, pageSize, options),
-    initialPageParam: 1,
-    getNextPageParam: (lastPage) => {
-      if (!lastPage.hasMore) return undefined;
-      return lastPage.page + 1;
-    },
-    ...queryOptions,
-  });
-}
-
-// ==========================================
-// MUTATION HOOKS (Auto-invalidation via React Query)
-// ==========================================
-
-/**
- * Create mutation - React Query handles cache invalidation
- * @example
- * const { mutate: createPost } = useRepositoryCreate('posts', {
- *   onSuccess: () => toast.success('Created!')
- * });
- */
-export function useRepositoryCreate<T = any>(
-  table: string,
-  options: Omit<UseMutationOptions<T, Error, Partial<T>>, "mutationFn"> & {
-    invalidate?: string[];
-  } = {},
-) {
-  const manager = getManager();
-  const queryClient = useQueryClient();
-  const { invalidate = [table], ...mutationOptions } = options;
-
-  return useMutation<T, Error, Partial<T>>({
-    mutationFn: (data) => manager.create<T>(table, data),
-    onSuccess: () => {
-      // React Query automatically invalidates and refetches
-      invalidate.forEach((t) => {
-        queryClient.invalidateQueries({ queryKey: queryKeys.all(t) });
-      });
-    },
-    ...mutationOptions,
-  });
-}
-
-/**
- * Update mutation - Optimistic update via React Query
- * @example
- * const { mutate: updatePost } = useRepositoryUpdate('posts', {
- *   onSuccess: () => toast.success('Updated!')
- * });
- * updatePost({ id: 1, data: { title: 'New Title' } });
- */
-export function useRepositoryUpdate<T = any>(
-  table: string,
-  options: Omit<
-    UseMutationOptions<T, Error, { id: number | string; data: Partial<T> }>,
-    "mutationFn"
-  > = {},
-) {
-  const manager = getManager();
-  const queryClient = useQueryClient();
-
-  return useMutation<T, Error, { id: number | string; data: Partial<T> }>({
-    mutationFn: ({ id, data }) => manager.update<T>(table, id, data),
-    onSuccess: (data, variables) => {
-      // Invalidate list queries
-      queryClient.invalidateQueries({ queryKey: queryKeys.all(table) });
-
-      // Update detail cache optimistically
-      queryClient.setQueryData(queryKeys.detail(table, variables.id), data);
-    },
-    ...options,
-  });
-}
-
-/**
- * Delete mutation
- * @example
- * const { mutate: deletePost } = useRepositoryDelete('posts', {
- *   onSuccess: () => toast.success('Deleted!')
- * });
- * deletePost(postId);
- */
-export function useRepositoryDelete(
-  table: string,
-  options: Omit<
-    UseMutationOptions<boolean, Error, number | string>,
-    "mutationFn"
-  > = {},
-) {
-  const manager = getManager();
-  const queryClient = useQueryClient();
-
-  return useMutation<boolean, Error, number | string>({
-    mutationFn: (id) => manager.delete(table, id),
-    onSuccess: (_data, id) => {
-      // Invalidate and remove from cache
-      queryClient.invalidateQueries({ queryKey: queryKeys.all(table) });
-      queryClient.removeQueries({ queryKey: queryKeys.detail(table, id) });
-    },
-    ...options,
-  });
-}
-
-// ==========================================
-// RAW SQL QUERY HOOKS
-// ==========================================
-
-/**
- * Raw SQL query hook - for complex queries that can't be expressed with QueryOptions
- * @example
- * // Complex JOIN query
- * const { data: posts } = useRawQuery<Post>(
- *   ['posts-with-categories', categorySlug],
- *   `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
- *    ORDER BY p.published_at DESC`,
- *   [categorySlug]
- * );
- *
- * // Aggregation query
- * const { data: stats } = useRawQuery<{total: number, avg: number}>(
- *   ['product-stats'],
- *   `SELECT COUNT(*) as total, AVG(price) as avg FROM products WHERE published = 1`
- * );
- */
-export function useRawQuery<T = any>(
-  queryKey: any[],
-  sql: string,
-  params?: any[],
-  options?: Omit<UseQueryOptions<T[], Error>, "queryKey" | "queryFn">,
-) {
-  const manager = getManager();
-
-  return useQuery<T[], Error>({
-    queryKey: ["raw", ...queryKey],
-    queryFn: () => manager.raw<T>(sql, params),
-    ...options,
-  });
-}
-
-/**
- * Raw SQL query hook for single result - aggregations, single lookups
- * @example
- * // Get price range
- * const { data: priceRange } = useRawQueryOne<{min: number, max: number}>(
- *   ['price-range'],
- *   `SELECT MIN(price) as min, MAX(price) as max FROM products WHERE published = 1`
- * );
- *
- * // Get single post with category
- * const { data: post } = useRawQueryOne<Post>(
- *   ['post-detail', slug],
- *   `SELECT p.*, c.name as category_name
- *    FROM posts p
- *    LEFT JOIN post_categories pc ON p.id = pc.post_id
- *    LEFT JOIN blog_categories c ON pc.category_id = c.id
- *    WHERE p.slug = ?`,
- *   [slug]
- * );
- */
-export function useRawQueryOne<T = any>(
-  queryKey: any[],
-  sql: string,
-  params?: any[],
-  options?: Omit<UseQueryOptions<T | null, Error>, "queryKey" | "queryFn">,
-) {
-  const manager = getManager();
-
-  return useQuery<T | null, Error>({
-    queryKey: ["raw", ...queryKey],
-    queryFn: () => manager.rawOne<T>(sql, params),
-    ...options,
-  });
-}

package/template/src/modules/db/utils/parsers.ts

@@ -1,96 +0,0 @@
-/**
- * Database field parsers - Client-side utilities
- * NO automatic parsing - client decides what to parse and when
- */
-
-/**
- * Parse comma-separated string to array
- * @example "tag1,tag2,tag3" -> ["tag1", "tag2", "tag3"]
- */
-export const parseCommaSeparatedString = (value: string): string[] => {
-  if (!value || typeof value !== "string") return [];
-  return value
-    .split(",")
-    .map((item) => item.trim())
-    .filter(Boolean);
-};
-
-/**
- * Parse JSON string to array
- * @example '["img1.jpg","img2.jpg"]' -> ["img1.jpg", "img2.jpg"]
- */
-export const parseJSONStringToArray = (value: string): string[] => {
-  if (!value || typeof value !== "string") return [];
-  try {
-    const parsed = JSON.parse(value);
-    return Array.isArray(parsed) ? parsed : [];
-  } catch (e) {
-    console.warn("Failed to parse JSON array:", value);
-    return [];
-  }
-};
-
-/**
- * Smart array parser - tries JSON first, falls back to comma-separated
- * @example '["a","b"]' -> ["a", "b"] OR "a,b" -> ["a", "b"]
- */
-export const parseStringToArray = (value: any): string[] => {
-  if (!value) return [];
-  if (Array.isArray(value)) return value;
-  if (typeof value !== "string") return [];
-
-  // Try JSON first
-  if (value.trim().startsWith("[")) {
-    const jsonResult = parseJSONStringToArray(value);
-    if (jsonResult.length > 0) return jsonResult;
-  }
-
-  // Fall back to comma-separated
-  return parseCommaSeparatedString(value);
-};
-
-/**
- * Parse JSON string to object
- * @example '{"key":"value"}' -> {key: "value"}
- */
-export const parseJSONString = <T = any>(
-  value: any,
-  defaultValue: T | null = null,
-): T | null => {
-  if (!value) return defaultValue;
-  if (typeof value === "object") return value; // Already parsed
-  if (typeof value !== "string") return defaultValue;
-
-  try {
-    return JSON.parse(value);
-  } catch (e) {
-    console.warn("Failed to parse JSON:", value);
-    return defaultValue;
-  }
-};
-
-/**
- * Parse SQLite boolean (0/1) to JavaScript boolean
- * @example 1 -> true, 0 -> false
- */
-export const parseSQLiteBoolean = (value: any): boolean => {
-  if (typeof value === "boolean") return value;
-  if (typeof value === "number") return value !== 0;
-  if (typeof value === "string") {
-    const lower = value.toLowerCase();
-    return lower === "true" || lower === "1" || lower === "yes";
-  }
-  return Boolean(value);
-};
-
-/**
- * Parse number safely with default fallback
- * @example "123" -> 123, "invalid" -> 0 (or provided default)
- */
-export const parseNumberSafe = (
-  value: any,
-  defaultValue: number = 0,
-): number => {
-  const num = Number(value);
-  return isNaN(num) ? defaultValue : num;
-};