@deessejs/collections 0.0.50 → 0.0.51

package/dist/config/index.d.ts

@@ -1,3 +1,2 @@
-import { drizzle } from "drizzle-orm/node-postgres";
 import { Config } from "./types";
-export declare const defineConfig: (config: Config) => ReturnType<typeof drizzle<any>>;
+export declare const defineConfig: (config: Config) => any;

package/dist/config/index.js

@@ -6,46 +6,40 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.defineConfig = void 0;
 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"
+// Fonction pour charger le schéma généré sans faire planter le build
 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à.
+        // 1. Essai via l'alias Webpack/Turbopack (Client/Server Next.js)
         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);
+            // 2. Essai via chemin système (Scripts/Worker)
+            return require(path_1.default.join(process.cwd(), ".deesse", "shadow", "schema.ts"));
         }
         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.");
+            // 3. Pas encore généré (Premier boot)
             return {};
         }
     }
 };
 const defineConfig = (config) => {
-    // 1. Charger le schéma généré
+    // Charger le schéma dynamiquement
     const schema = loadGeneratedSchema();
-    // 2. Initialiser Drizzle AVEC le schéma
+    // Initialiser Drizzle avec le schéma
     const db = (0, node_postgres_1.drizzle)(config.databaseUrl, {
         schema,
-        // logger: true // utile pour debug
+        // logger: true // Décommentez pour debug
     });
-    // 3. Attacher la config pour le worker (votre code existant)
+    // Attacher la config brute pour que le Worker puisse la lire via Jiti
     Object.defineProperty(db, '_config', {
         value: config,
         enumerable: false,
         writable: false
     });
-    // 4. On caste le retour pour faire croire à TS qu'on a le bon typage
-    // (Voir section Typage ci-dessous)
+    // On retourne "any" ici au niveau du runtime de la lib.
+    // La vraie magie se passe dans .deesse/types.d.ts qui surcharge ce type
+    // pour l'utilisateur final.
     return db;
 };
 exports.defineConfig = defineConfig;

package/dist/drizzle/generate.js

@@ -6,19 +6,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateShadowSchema = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const _1 = require(".");
+const _1 = require("."); // Assurez-vous que cet import est correct dans votre structure
 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]) => {
+            // @ts-ignore - TODO: typer proprement l'accès au DSL
             const kind = field.type.dsl.kind;
             const drizzleType = Object.keys(_1.DrizzleTypes).includes(kind)
-                // @ts-ignore
-                ? `p.${kind}()` // TODO: gérer les params (varchar(255), etc.)
+                ? `p.${kind}()` // TODO: Ajouter params (ex: varchar(255))
                 : `p.text()`;
             return `  ${name}: ${drizzleType},`;
         })
@@ -28,29 +27,23 @@ 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
+    // On prépare la section relations (vide pour l'instant, mais requise pour db.query)
+    // On liste les tables dans l'objet relations
+    const tableNames = collections.map(c => c.slug).join(", ");
     const schemaFileContent = `
 import * as p from "drizzle-orm/pg-core";
 import { relations } from "drizzle-orm";
 
-// --- Tables ---
+// --- Tables Generated ---
 ${tablesCode.join("\n")}
 
-// --- Relations ---
-// (Note: Pour l'instant on ne génère pas de relations complexes automatiquement, 
-// mais on prépare le terrain)
+// --- Relations Placeholder ---
+// Nécessaire pour que db.query fonctionne, même vide
+export const schemaRelations = relations({ ${tableNames} }, (helpers) => ({
+  // TODO: Implémenter la logique de relations basée sur les champs de collection
+}));
 `;
     fs_1.default.writeFileSync(SCHEMA_PATH, schemaFileContent);
-    console.log("[Deesse] ✅ Shadow schema generated at", SCHEMA_PATH);
+    // console.log("[Deesse] ✅ Schema generated at", SCHEMA_PATH);
 };
 exports.generateShadowSchema = generateShadowSchema;

package/dist/next/index.js

@@ -9,12 +9,12 @@ const constants_1 = require("next/constants");
 const path_1 = __importDefault(require("path"));
 const withCollections = (phase, config) => {
     const isDev = phase === constants_1.PHASE_DEVELOPMENT_SERVER;
-    // 1. Lancer le worker en arrière-plan (votre code actuel)
+    // 1. Lancement du Worker
     if (isDev && !global.__collections_worker_started) {
         global.__collections_worker_started = true;
-        // Assurez-vous que ce chemin pointe vers le JS compilé de votre lib
-        const workerPath = path_1.default.resolve(__dirname, "../worker/index.js");
-        console.log("[Deesse] Spawning background worker:", workerPath);
+        // Chemin vers le fichier JS compilé du worker dans node_modules
+        const workerPath = path_1.default.join(__dirname, "../worker/index.js");
+        console.log("[Deesse] Spawning background worker");
         (0, child_process_1.spawn)("node", [workerPath], {
             stdio: "inherit",
             env: { ...process.env },
@@ -24,34 +24,31 @@ const withCollections = (phase, config) => {
     const shadowSchemaPath = path_1.default.join(process.cwd(), ".deesse", "shadow", "schema.ts");
     return {
         ...config,
-        // 2. Configuration pour Turbopack (Next.js 16+)
+        // 2. Config Turbopack (Next 16+)
         turbopack: {
             ...(config.turbopack || {}),
             resolveAlias: {
                 ...(config.turbopack?.resolveAlias || {}),
-                // Création de l'alias pour Turbopack
                 "@deesse/schema": shadowSchemaPath,
             },
         },
-        // 3. Configuration pour Webpack (Next.js < 16 ou --webpack)
+        // 3. Config Webpack (Next <16 ou fallback)
         webpack: (webpackConfig, options) => {
-            // Appliquer la config utilisateur existante s'il y en a une
             if (typeof config.webpack === "function") {
                 webpackConfig = config.webpack(webpackConfig, options);
             }
-            // Création de l'alias pour Webpack
+            // Alias pour que require("@deesse/schema") fonctionne dans defineConfig
             webpackConfig.resolve.alias["@deesse/schema"] = shadowSchemaPath;
             return webpackConfig;
         },
-        // 4. Empêcher le bundling des paquets serveur (Drizzle, PG, etc.)
-        // C'est crucial pour éviter les erreurs de compilation côté Next
+        // 4. Empêcher le bundling des dépendances serveur
         serverExternalPackages: [
             ...(config.serverExternalPackages || []),
             "drizzle-orm",
             "drizzle-kit",
             "pg",
-            "jiti", // Important pour que Jiti ne soit pas bundlé si utilisé côté serveur
-            "@deessejs/collections", // Votre lib
+            "jiti",
+            "@deessejs/collections",
         ],
     };
 };

package/dist/worker/index.js

@@ -11,22 +11,17 @@ const generate_1 = require("../drizzle/generate");
 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");
+const DEESSE_DIR = path_1.default.join(PROJECT_ROOT, ".deesse");
+const TYPES_PATH = path_1.default.join(DEESSE_DIR, "types.d.ts");
 /**
- * Utilise Jiti pour lire le tsconfig.json.
- * Jiti gère nativement le JSONC (commentaires, trailing commas)
- * que JSON.parse ne supporte pas.
+ * Charge les alias depuis tsconfig.json pour que jiti puisse résoudre "@/..."
  */
 function getTsConfigAliases(root) {
     const tsConfigPath = path_1.default.join(root, "tsconfig.json");
-    if (!fs_1.default.existsSync(tsConfigPath)) {
+    if (!fs_1.default.existsSync(tsConfigPath))
         return {};
-    }
     try {
-        // 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;
@@ -35,7 +30,6 @@ function getTsConfigAliases(root) {
         const aliases = {};
         for (const [key, values] of Object.entries(paths)) {
             const value = Array.isArray(values) ? values[0] : values;
-            // Conversion: "@/*" -> "src/*"  ===>  "@" -> "/abs/path/to/src"
             const aliasKey = key.replace("/*", "");
             const aliasValue = String(value).replace("/*", "");
             aliases[aliasKey] = path_1.default.resolve(root, aliasValue);
@@ -47,37 +41,55 @@ function getTsConfigAliases(root) {
         return {};
     }
 }
-// --- Initialisation ---
-// 1. Récupération des alias (ex: { "@": "C:/.../src" })
+/**
+ * Génère le fichier de définition de types (.d.ts) pour surcharger defineConfig
+ */
+function generateTypeDefinitions() {
+    // On s'assure que le dossier existe
+    if (!fs_1.default.existsSync(DEESSE_DIR)) {
+        fs_1.default.mkdirSync(DEESSE_DIR, { recursive: true });
+    }
+    const typeDefContent = `
+// Ce fichier est généré automatiquement par Deesse.
+// Il permet d'avoir le typage strict sur db.query.*
+
+import type * as Schema from "./shadow/schema";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type { Config } from "@deessejs/collections";
+
+declare module "@deessejs/collections" {
+  export function defineConfig(config: Config): NodePgDatabase<typeof Schema> & { _config: Config };
+}
+`;
+    fs_1.default.writeFileSync(TYPES_PATH, typeDefContent);
+}
+// Initialisation Jiti
 const aliases = getTsConfigAliases(PROJECT_ROOT);
-// 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, // Injection des alias pour que "@/collections/posts" fonctionne
+    alias: aliases,
 });
 async function runGenerator() {
     try {
-        if (!fs_1.default.existsSync(CONFIG_PATH)) {
+        if (!fs_1.default.existsSync(CONFIG_PATH))
             return;
-        }
-        // Importation de la config utilisateur
-        // Grâce à l'étape précédente, les imports avec "@/" fonctionnent maintenant
+        // Charger la config utilisateur
         const mod = await jiti.import(CONFIG_PATH);
         const dbInstance = mod.db || mod.default;
-        if (!dbInstance || !dbInstance._config) {
+        if (!dbInstance || !dbInstance._config)
             return;
-        }
         const collections = dbInstance._config.collections;
-        // Génération du schéma
+        // 1. Générer le schéma Drizzle (schema.ts)
         (0, generate_1.generateShadowSchema)(collections);
+        // 2. Générer les définitions TypeScript (types.d.ts)
+        generateTypeDefinitions();
     }
     catch (error) {
-        // On log l'erreur proprement pour le debugging
         console.error("[Deesse] ❌ Worker Error:", error);
     }
 }
-// --- Exécution ---
+// Lancement
 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.50",
+  "version": "0.0.51",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",