@promakeai/cli 0.4.7 → 0.5.0

package/template/scripts/init-db.ts

@@ -1,131 +1,18 @@
-import fs from "fs";
+import { execSync } from "child_process";
 import path from "path";
-import initSqlJs from "sql.js";
 
-async function createDatabase() {
-  const SQL = await initSqlJs();
-  const db = new SQL.Database();
+const cwd = process.cwd();
+const schemaPath = path.join(cwd, "src", "db", "schema.json");
+const outputDir = path.join(cwd, "src", "db");
+const dbPath = path.join(cwd, "public", "data", "database.db");
 
-  // ============================================
-  // BLOG SISTEMI
-  // ============================================
+const cmd = `dbcli generate --schema "${schemaPath}" --database "${dbPath}" --output "${outputDir}"`;
 
-  db.exec(`
-    CREATE TABLE blog_categories (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      name TEXT NOT NULL,
-      slug TEXT UNIQUE NOT NULL,
-      description TEXT,
-      image TEXT,
-      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
-    );
-  `);
-
-  db.exec(`
-    CREATE TABLE posts (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      title TEXT NOT NULL,
-      slug TEXT UNIQUE NOT NULL,
-      content TEXT NOT NULL,
-      excerpt TEXT,
-      featured_image TEXT,
-      images TEXT,
-      author TEXT,
-      author_avatar TEXT,
-      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-      published_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-      tags TEXT,
-      read_time INTEGER DEFAULT 0,
-      view_count INTEGER DEFAULT 0,
-      featured INTEGER DEFAULT 0,
-      published INTEGER DEFAULT 1,
-      meta_description TEXT,
-      meta_keywords TEXT
-    );
-  `);
-
-  db.exec(`
-    CREATE TABLE post_categories (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      post_id INTEGER NOT NULL,
-      category_id INTEGER NOT NULL,
-      is_primary INTEGER DEFAULT 0,
-      FOREIGN KEY (post_id) REFERENCES posts(id) ON DELETE CASCADE,
-      FOREIGN KEY (category_id) REFERENCES blog_categories(id) ON DELETE CASCADE
-    );
-  `);
-
-  // ============================================
-  // E-COMMERCE SISTEMI
-  // ============================================
-
-  db.exec(`
-    CREATE TABLE product_categories (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      name TEXT NOT NULL,
-      slug TEXT UNIQUE NOT NULL,
-      description TEXT,
-      image TEXT,
-      parent_id INTEGER,
-      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-      FOREIGN KEY (parent_id) REFERENCES product_categories(id) ON DELETE SET NULL
-    );
-  `);
-
-  db.exec(`
-    CREATE TABLE products (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      name TEXT NOT NULL,
-      slug TEXT UNIQUE NOT NULL,
-      description TEXT,
-      price REAL NOT NULL,
-      sale_price REAL,
-      on_sale INTEGER DEFAULT 0,
-      images TEXT,
-      brand TEXT,
-      sku TEXT,
-      stock INTEGER DEFAULT 0,
-      tags TEXT,
-      rating REAL DEFAULT 0,
-      review_count INTEGER DEFAULT 0,
-      featured INTEGER DEFAULT 0,
-      is_new INTEGER DEFAULT 0,
-      published INTEGER DEFAULT 1,
-      specifications TEXT,
-      variants TEXT,
-      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-      meta_description TEXT,
-      meta_keywords TEXT
-    );
-  `);
-
-  db.exec(`
-    CREATE TABLE product_category_relations (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      product_id INTEGER NOT NULL,
-      category_id INTEGER NOT NULL,
-      is_primary INTEGER DEFAULT 0,
-      FOREIGN KEY (product_id) REFERENCES products(id) ON DELETE CASCADE,
-      FOREIGN KEY (category_id) REFERENCES product_categories(id) ON DELETE CASCADE
-    );
-  `);
-
-  // Database'i dosyaya kaydet
-  const data = db.export();
-  const buffer = Buffer.from(data);
-
-  const outputPath = path.join(process.cwd(), "public/data/database.db");
-  fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-  fs.writeFileSync(outputPath, buffer);
-
-  console.log(`Database olusturuldu: ${outputPath}`);
-  console.log("Tablolar (6):");
-  console.log("  - blog_categories, posts, post_categories");
-  console.log("  - product_categories, products, product_category_relations");
+try {
+  console.log("Generating database with dbcli...");
+  execSync(cmd, { stdio: "inherit" });
+  console.log(`Database created: ${dbPath}`);
+} catch (err) {
+  console.error("Failed to generate database. Ensure dbcli is installed globally.");
+  throw err;
 }
-
-createDatabase().catch(console.error);

package/template/src/App.tsx

@@ -1,15 +1,18 @@
 import { TooltipProvider } from "@/components/ui/tooltip";
 import { GoogleAnalytics } from "@/components/GoogleAnalytics";
 import { ScriptInjector } from "@/components/ScriptInjector";
+import { AppDbProvider } from "@/db";
 import { Router } from "./router";
 
 const App = () => {
   return (
-    <TooltipProvider>
-      <GoogleAnalytics />
-      <ScriptInjector />
-      <Router />
-    </TooltipProvider>
+    <AppDbProvider>
+      <TooltipProvider>
+        <GoogleAnalytics />
+        <ScriptInjector />
+        <Router />
+      </TooltipProvider>
+    </AppDbProvider>
   );
 };
 

package/template/src/components/FormField.tsx

@@ -1,17 +1,15 @@
 import { Stack } from "./Stack";
 import { Label } from "./ui/label";
 
-// FormField.tsx
 export interface FormFieldProps {
-  label: React.ReactNode;
+  label: string;
   htmlFor?: string;
   error?: string;
   required?: boolean;
   description?: string;
   children: React.ReactNode;
-  gap?: 0 | 1 | 2 | 3 | 4 | 6 | 8 | 10 | 12;
+  gap?: 0 | 1 | 2 | 3 | 4 | 6 | 8 | 10 | 12; // Stack gap override
   className?: string;
-  labelAction?: React.ReactNode; // YENİ
 }
 
 export function FormField({ 
@@ -23,16 +21,12 @@ export function FormField({
   description,
   gap = 2,
   className,
-  labelAction, // YENİ
 }: FormFieldProps) {
   return (
     <Stack gap={gap} className={className}>
-      <div className="flex items-center justify-between">
-        <Label htmlFor={htmlFor}>
-          {label} {required && <span className="text-destructive">*</span>}
-        </Label>
-        {labelAction}
-      </div>
+      <Label htmlFor={htmlFor}>
+        {label} {required && <span className="text-destructive">*</span>}
+      </Label>
       {children}
       {description && (
         <p className="text-sm text-muted-foreground">

package/template/src/db/index.ts

@@ -0,0 +1,20 @@
+export { AppDbProvider } from "./provider";
+
+import { parseJSONSchema } from "@promakeai/dbreact";
+import schemaJson from "./schema.json";
+export const schema = parseJSONSchema(schemaJson as any);
+
+export {
+  useDb,
+  useAdapter,
+  useDbLang,
+  useDbList,
+  useDbGet,
+  useDbCreate,
+  useDbUpdate,
+  useDbDelete,
+  SqliteAdapter,
+  parseJSONSchema,
+} from "@promakeai/dbreact";
+
+export * from "./types";

package/template/src/db/provider.tsx

@@ -0,0 +1,77 @@
+import { useEffect, useState, type ReactNode } from "react";
+import { useTranslation } from "react-i18next";
+import { DbProvider, SqliteAdapter, parseJSONSchema } from "@promakeai/dbreact";
+import constants from "@/constants/constants.json";
+import schemaJson from "./schema.json";
+
+const schema = parseJSONSchema(schemaJson as any);
+
+interface AppDbProviderProps {
+  children: ReactNode;
+}
+
+const DEFAULT_LANG = constants?.site?.defaultLanguage || "en";
+
+export function AppDbProvider({ children }: AppDbProviderProps) {
+  const { i18n } = useTranslation();
+  const [adapter, setAdapter] = useState<SqliteAdapter | null>(null);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    let cancelled = false;
+
+    async function loadDb() {
+      try {
+        const response = await fetch("/data/database.db");
+        if (!response.ok) {
+          throw new Error(
+            `Failed to load database: ${response.status} ${response.statusText}`
+          );
+        }
+
+        const buffer = await response.arrayBuffer();
+        if (cancelled) return;
+
+        const dbAdapter = new SqliteAdapter({
+          schema,
+          defaultLang: DEFAULT_LANG,
+        });
+
+        await dbAdapter.connect();
+        await dbAdapter.import(new Uint8Array(buffer));
+
+        if (!cancelled) {
+          setAdapter(dbAdapter);
+        }
+      } catch (err) {
+        if (!cancelled) {
+          setError(err instanceof Error ? err : new Error(String(err)));
+        }
+      }
+    }
+
+    loadDb();
+
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+
+  if (error) {
+    console.error(error);
+  }
+
+  if (!adapter) {
+    return null;
+  }
+
+  return (
+    <DbProvider
+      adapter={adapter}
+      lang={i18n?.language || DEFAULT_LANG}
+      fallbackLang={DEFAULT_LANG}
+    >
+      {children}
+    </DbProvider>
+  );
+}

package/template/src/db/schema.json

@@ -0,0 +1,259 @@
+{
+  "name": "promake",
+  "languages": [
+    "en",
+    "tr"
+  ],
+  "defaultLanguage": "en",
+  "tables": {
+    "blog_categories": {
+      "id": {
+        "type": "id"
+      },
+      "name": {
+        "type": "string",
+        "nullable": false,
+        "translatable": true
+      },
+      "slug": {
+        "type": "string",
+        "nullable": false,
+        "unique": true
+      },
+      "description": {
+        "type": "text",
+        "translatable": true
+      },
+      "image": {
+        "type": "text"
+      },
+      "created_at": {
+        "type": "timestamp"
+      },
+      "updated_at": {
+        "type": "timestamp"
+      }
+    },
+    "posts": {
+      "id": {
+        "type": "id"
+      },
+      "title": {
+        "type": "string",
+        "nullable": false,
+        "translatable": true
+      },
+      "slug": {
+        "type": "string",
+        "nullable": false,
+        "unique": true
+      },
+      "content": {
+        "type": "text",
+        "nullable": false,
+        "translatable": true
+      },
+      "excerpt": {
+        "type": "text",
+        "translatable": true
+      },
+      "featured_image": {
+        "type": "text"
+      },
+      "images": {
+        "type": [
+          "string"
+        ]
+      },
+      "author": {
+        "type": "string",
+        "translatable": true
+      },
+      "author_avatar": {
+        "type": "text"
+      },
+      "created_at": {
+        "type": "timestamp"
+      },
+      "published_at": {
+        "type": "timestamp"
+      },
+      "updated_at": {
+        "type": "timestamp"
+      },
+      "tags": {
+        "type": [
+          "string"
+        ]
+      },
+      "categories": {
+        "type": [
+          "number"
+        ],
+        "ref": "blog_categories"
+      },
+      "read_time": {
+        "type": "int",
+        "default": 0
+      },
+      "view_count": {
+        "type": "int",
+        "default": 0
+      },
+      "featured": {
+        "type": "bool",
+        "default": false
+      },
+      "published": {
+        "type": "bool",
+        "default": true
+      },
+      "meta_description": {
+        "type": "text",
+        "translatable": true
+      },
+      "meta_keywords": {
+        "type": "text",
+        "translatable": true
+      }
+    },
+    "product_categories": {
+      "id": {
+        "type": "id"
+      },
+      "name": {
+        "type": "string",
+        "nullable": false,
+        "translatable": true
+      },
+      "slug": {
+        "type": "string",
+        "nullable": false,
+        "unique": true
+      },
+      "description": {
+        "type": "text",
+        "translatable": true
+      },
+      "image": {
+        "type": "text"
+      },
+      "parent_id": {
+        "type": "int",
+        "ref": "product_categories"
+      },
+      "created_at": {
+        "type": "timestamp"
+      },
+      "updated_at": {
+        "type": "timestamp"
+      }
+    },
+    "products": {
+      "id": {
+        "type": "id"
+      },
+      "name": {
+        "type": "string",
+        "nullable": false,
+        "translatable": true
+      },
+      "slug": {
+        "type": "string",
+        "nullable": false,
+        "unique": true
+      },
+      "description": {
+        "type": "text",
+        "translatable": true
+      },
+      "price": {
+        "type": "decimal",
+        "nullable": false
+      },
+      "sale_price": {
+        "type": "decimal"
+      },
+      "on_sale": {
+        "type": "bool",
+        "default": false
+      },
+      "images": {
+        "type": [
+          "string"
+        ]
+      },
+      "brand": {
+        "type": "string",
+        "translatable": true
+      },
+      "sku": {
+        "type": "string"
+      },
+      "stock": {
+        "type": "int",
+        "default": 0
+      },
+      "tags": {
+        "type": [
+          "string"
+        ]
+      },
+      "categories": {
+        "type": [
+          "number"
+        ],
+        "ref": "product_categories"
+      },
+      "rating": {
+        "type": "decimal",
+        "default": 0
+      },
+      "review_count": {
+        "type": "int",
+        "default": 0
+      },
+      "featured": {
+        "type": "bool",
+        "default": false
+      },
+      "is_new": {
+        "type": "bool",
+        "default": false
+      },
+      "published": {
+        "type": "bool",
+        "default": true
+      },
+      "specifications": {
+        "type": "json"
+      },
+      "variants": {
+        "type": [
+          {
+            "id": "string",
+            "name": "string",
+            "value": "string",
+            "price?": "number",
+            "image?": "string",
+            "stockQuantity": "number"
+          }
+        ]
+      },
+      "created_at": {
+        "type": "timestamp"
+      },
+      "updated_at": {
+        "type": "timestamp"
+      },
+      "meta_description": {
+        "type": "text",
+        "translatable": true
+      },
+      "meta_keywords": {
+        "type": "text",
+        "translatable": true
+      }
+    }
+  }
+}