@deessejs/collections 0.0.48 → 0.0.50

package/dist/config/index.d.ts

@@ -1,4 +1,3 @@
+import { drizzle } from "drizzle-orm/node-postgres";
 import { Config } from "./types";
-export declare const defineConfig: (config: Config) => import("drizzle-orm/node-postgres").NodePgDatabase<Record<string, never>> & {
-    $client: import("pg").Pool;
-};
+export declare const defineConfig: (config: Config) => ReturnType<typeof drizzle<any>>;

package/dist/config/index.js

@@ -1,19 +1,51 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defineConfig = void 0;
-// src/core/index.ts (ou là où est défini defineConfig)
 const node_postgres_1 = require("drizzle-orm/node-postgres");
+const path_1 = __importDefault(require("path"));
+// Fonction utilitaire pour charger le schéma de manière "lazy"
+const loadGeneratedSchema = () => {
+    try {
+        // 1. Essayer via l'alias Webpack (fonctionne dans Next.js)
+        // On utilise un require dynamique pour éviter que le bundler ne râle à la compilation
+        // si le fichier n'est pas là.
+        return require("@deesse/schema");
+    }
+    catch (e) {
+        try {
+            // 2. Fallback : Essayer le chemin physique (si on est hors contexte webpack, ex: scripts)
+            const localPath = path_1.default.join(process.cwd(), ".deesse", "shadow", "schema.ts");
+            // Note: require de fichier .ts natif nécessite jiti ou ts-node, 
+            // mais en prod Next.js ce sera compilé.
+            // En dev, Next.js gère le TS.
+            return require(localPath);
+        }
+        catch (e2) {
+            // 3. Premier lancement : le schéma n'existe pas encore
+            console.warn("[Deesse] ⚠️ Schema not found. 'db.query' will be empty until schema generation completes.");
+            return {};
+        }
+    }
+};
 const defineConfig = (config) => {
-    const db = (0, node_postgres_1.drizzle)(config.databaseUrl);
-    // Attacher la config cachée pour que le worker puisse la lire
-    // sans avoir besoin de parser l'AST manuellement
+    // 1. Charger le schéma généré
+    const schema = loadGeneratedSchema();
+    // 2. Initialiser Drizzle AVEC le schéma
+    const db = (0, node_postgres_1.drizzle)(config.databaseUrl, {
+        schema,
+        // logger: true // utile pour debug
+    });
+    // 3. Attacher la config pour le worker (votre code existant)
     Object.defineProperty(db, '_config', {
         value: config,
-        enumerable: false, // Pour ne pas polluer les logs de console.log(db)
+        enumerable: false,
         writable: false
     });
-    // Optionnel : Génération initiale synchrone si on veut bloquer le démarrage
-    // generateShadowSchema(config.collections); 
+    // 4. On caste le retour pour faire croire à TS qu'on a le bon typage
+    // (Voir section Typage ci-dessous)
     return db;
 };
 exports.defineConfig = defineConfig;

package/dist/drizzle/generate.js

@@ -11,12 +11,14 @@ const SHADOW_DIR = path_1.default.join(process.cwd(), ".deesse", "shadow");
 const SCHEMA_PATH = path_1.default.join(SHADOW_DIR, "schema.ts");
 const generateShadowSchema = (collections) => {
     fs_1.default.mkdirSync(SHADOW_DIR, { recursive: true });
+    // 1. Générer le code des tables
     const tablesCode = collections.map((col) => {
         const columns = Object.entries(col.fields)
             .map(([name, field]) => {
             const kind = field.type.dsl.kind;
             const drizzleType = Object.keys(_1.DrizzleTypes).includes(kind)
-                ? `p.${kind}()`
+                // @ts-ignore
+                ? `p.${kind}()` // TODO: gérer les params (varchar(255), etc.)
                 : `p.text()`;
             return `  ${name}: ${drizzleType},`;
         })
@@ -26,12 +28,29 @@ export const ${col.slug} = p.pgTable("${col.slug}", {
 ${columns}
 });`;
     });
+    // 2. Générer le code des relations (Pour l'instant vide ou basique)
+    // Drizzle a besoin de "relations" importé de "drizzle-orm"
+    const relationsCode = `
+import { relations } from "drizzle-orm";
+
+// Placeholder pour les relations futures
+export const schemaRelations = relations(posts, ({ one, many }) => ({
+  // Logique à implémenter plus tard en lisant les champs "relationship" de vos collections
+}));
+`;
+    // 3. Assembler le fichier
     const schemaFileContent = `
 import * as p from "drizzle-orm/pg-core";
+import { relations } from "drizzle-orm";
 
+// --- Tables ---
 ${tablesCode.join("\n")}
+
+// --- Relations ---
+// (Note: Pour l'instant on ne génère pas de relations complexes automatiquement, 
+// mais on prépare le terrain)
 `;
     fs_1.default.writeFileSync(SCHEMA_PATH, schemaFileContent);
-    console.log("[Deesse] Shadow schema generated at", SCHEMA_PATH);
+    console.log("[Deesse] ✅ Shadow schema generated at", SCHEMA_PATH);
 };
 exports.generateShadowSchema = generateShadowSchema;

package/dist/worker/index.js

@@ -12,8 +12,9 @@ const PROJECT_ROOT = process.cwd();
 const CONFIG_PATH = path_1.default.join(PROJECT_ROOT, "src", "api", "index.ts");
 const COLLECTIONS_DIR = path_1.default.join(PROJECT_ROOT, "src", "collections");
 /**
- * Lit le tsconfig.json pour extraire les paths (alias)
- * et les convertir au format attendu par Jiti/Node.
+ * Utilise Jiti pour lire le tsconfig.json.
+ * Jiti gère nativement le JSONC (commentaires, trailing commas)
+ * que JSON.parse ne supporte pas.
  */
 function getTsConfigAliases(root) {
     const tsConfigPath = path_1.default.join(root, "tsconfig.json");
@@ -21,60 +22,62 @@ function getTsConfigAliases(root) {
         return {};
     }
     try {
-        // Lecture brute + nettoyage des commentaires (JSON standard ne supporte pas les commentaires)
-        const content = fs_1.default.readFileSync(tsConfigPath, "utf-8");
-        // Regex simple pour retirer les commentaires // et /* */
-        const jsonContent = content.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
-        const tsConfig = JSON.parse(jsonContent);
+        // 1. On crée une instance temporaire de Jiti juste pour lire la config
+        const tempJiti = (0, jiti_1.createJiti)(root, { requireCache: false });
+        // 2. On charge le fichier. Jiti va le parser correctement.
+        // Note: selon la version de jiti, pour du JSON, il retourne l'objet directement
+        // ou un module avec export default.
+        const loaded = tempJiti(tsConfigPath);
+        const tsConfig = loaded.default || loaded;
         const paths = tsConfig?.compilerOptions?.paths;
         if (!paths)
             return {};
         const aliases = {};
         for (const [key, values] of Object.entries(paths)) {
             const value = Array.isArray(values) ? values[0] : values;
-            // Conversion de la syntaxe TS ("@/*": ["./src/*"]) vers syntaxe alias simple ("@": "/abs/src")
+            // Conversion: "@/*" -> "src/*"  ===>  "@" -> "/abs/path/to/src"
             const aliasKey = key.replace("/*", "");
             const aliasValue = String(value).replace("/*", "");
-            // Jiti a besoin de chemins absolus pour les alias
             aliases[aliasKey] = path_1.default.resolve(root, aliasValue);
         }
         return aliases;
     }
     catch (error) {
-        console.warn("[Deesse] ⚠️ Failed to parse tsconfig.json for aliases", error);
+        console.warn("[Deesse] ⚠️ Failed to load aliases from tsconfig.json", error);
         return {};
     }
 }
-// 1. Charger les alias (ex: { "@": "C:/.../src" })
+// --- Initialisation ---
+// 1. Récupération des alias (ex: { "@": "C:/.../src" })
 const aliases = getTsConfigAliases(PROJECT_ROOT);
-// 2. Initialiser Jiti avec les alias injectés
+// 2. Initialisation de l'instance principale de Jiti avec les alias
 const jiti = (0, jiti_1.createJiti)(PROJECT_ROOT, {
     interopDefault: true,
     requireCache: false,
-    alias: aliases, // <--- C'est ici que la magie opère
+    alias: aliases, // Injection des alias pour que "@/collections/posts" fonctionne
 });
 async function runGenerator() {
     try {
         if (!fs_1.default.existsSync(CONFIG_PATH)) {
             return;
         }
-        // Importation de la config
+        // Importation de la config utilisateur
+        // Grâce à l'étape précédente, les imports avec "@/" fonctionnent maintenant
         const mod = await jiti.import(CONFIG_PATH);
         const dbInstance = mod.db || mod.default;
         if (!dbInstance || !dbInstance._config) {
             return;
         }
         const collections = dbInstance._config.collections;
-        // Génération
+        // Génération du schéma
         (0, generate_1.generateShadowSchema)(collections);
-        // Feedback visuel discret (optionnel)
-        // console.log("[Deesse] Schema synced");
     }
     catch (error) {
+        // On log l'erreur proprement pour le debugging
         console.error("[Deesse] ❌ Worker Error:", error);
     }
 }
-// --- Lancement ---
+// --- Exécution ---
 runGenerator();
 console.log(`[Deesse] 👀 Watching collections...`);
 const watcher = chokidar_1.default.watch([CONFIG_PATH, COLLECTIONS_DIR], {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deessejs/collections",
-  "version": "0.0.48",
+  "version": "0.0.50",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",