@deessejs/collections 0.0.49 → 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/package.json

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