@deessejs/collections 0.0.39 → 0.0.41

package/dist/config/index.d.ts

@@ -2,3 +2,4 @@ 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 waitConfig: () => Promise<Config>;

package/dist/config/index.js

@@ -1,31 +1,18 @@
 "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;
+exports.waitConfig = exports.defineConfig = void 0;
 const node_postgres_1 = require("drizzle-orm/node-postgres");
-// Remarque : on importe depuis "fs" tout court, pas "fs/promises"
-const fs_1 = require("fs");
-const path_1 = __importDefault(require("path"));
-// Fonction utilitaire SYNCHRONE
-const writeSchemaFileSync = () => {
-    try {
-        const targetPath = path_1.default.join(process.cwd(), ".deesse", "schema.ts");
-        const targetDir = path_1.default.dirname(targetPath);
-        // mkdirSync et writeFileSync bloquent l'exécution jusqu'à la fin de l'écriture
-        (0, fs_1.mkdirSync)(targetDir, { recursive: true });
-        (0, fs_1.writeFileSync)(targetPath, "hey", "utf-8");
-        console.log(`[config] Schema written to: ${targetPath}`);
-    }
-    catch (error) {
-        console.error("[config] Failed to write schema file:", error);
-    }
-};
+let _config;
 const defineConfig = (config) => {
+    _config = config;
     const db = (0, node_postgres_1.drizzle)(config.databaseUrl);
-    // On peut l'appeler sans await
-    writeSchemaFileSync();
     return db;
 };
 exports.defineConfig = defineConfig;
+const waitConfig = async () => {
+    while (!_config) {
+        await new Promise((r) => setTimeout(r, 50));
+    }
+    return _config;
+};
+exports.waitConfig = waitConfig;

package/dist/drizzle/generate.d.ts

@@ -1 +1,2 @@
-export declare const generateShadowSchema: () => void;
+import { Collection } from "../collections/types";
+export declare const generateShadowSchema: (collections: Collection[]) => void;

package/dist/drizzle/generate.js

@@ -6,12 +6,32 @@ 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 SHADOW_DIR = path_1.default.join(process.cwd(), ".deesse", "shadow");
 const SCHEMA_PATH = path_1.default.join(SHADOW_DIR, "schema.ts");
-const generateShadowSchema = () => {
+const generateShadowSchema = (collections) => {
     fs_1.default.mkdirSync(SHADOW_DIR, { recursive: true });
-    // Ajoute "hey" à la fin du fichier
-    fs_1.default.appendFileSync(SCHEMA_PATH, "hey\n");
-    console.log("[Deesse] Added 'hey' to", SCHEMA_PATH);
+    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}()`
+                : `p.text()`;
+            return `  ${name}: ${drizzleType},`;
+        })
+            .join("\n");
+        return `
+export const ${col.slug} = p.pgTable("${col.slug}", {
+${columns}
+});`;
+    });
+    const schemaFileContent = `
+import * as p from "drizzle-orm/pg-core";
+
+${tablesCode.join("\n")}
+`;
+    fs_1.default.writeFileSync(SCHEMA_PATH, schemaFileContent);
+    console.log("[Deesse] Shadow schema generated at", SCHEMA_PATH);
 };
 exports.generateShadowSchema = generateShadowSchema;

package/dist/worker/index.d.ts

@@ -1 +1,2 @@
-export {};
+import { Collection } from "../collections/types";
+export declare const loadCollections: () => Promise<Collection[]>;

package/dist/worker/index.js

@@ -1,35 +1,72 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const chokidar_1 = __importDefault(require("chokidar"));
+exports.loadCollections = void 0;
+const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const generate_1 = require("../drizzle/generate");
+// Dossier des collections
 const collectionsDir = path_1.default.join(process.cwd(), "src", "collections");
-console.log(`[worker] Watching collections folder: ${collectionsDir}`);
-(0, generate_1.generateShadowSchema)();
-const watcher = chokidar_1.default.watch(collectionsDir, {
-    persistent: true,
-    ignoreInitial: false,
-    depth: 2,
-    awaitWriteFinish: {
-        stabilityThreshold: 100,
-        pollInterval: 50,
-    },
-});
-watcher
-    .on("add", (filePath) => {
-    console.log(`[worker] File added: ${filePath}`);
-})
-    .on("change", (filePath) => {
-    console.log(`[worker] File changed: ${filePath}`);
-})
-    .on("unlink", (filePath) => {
-    console.log(`[worker] File removed: ${filePath}`);
-})
-    .on("error", (err) => {
-    const error = err instanceof Error ? err : new Error(String(err));
-    console.error("[worker] Watcher error:", error);
-});
-console.log("[worker] Watcher started");
+console.log(`[worker] Loading collections from ${collectionsDir}`);
+// Fonction pour importer toutes les collections
+const loadCollections = async () => {
+    const files = fs_1.default
+        .readdirSync(collectionsDir)
+        .filter((f) => f.endsWith(".ts") || f.endsWith(".js"));
+    const collections = [];
+    for (const file of files) {
+        const fullPath = path_1.default.join(collectionsDir, file);
+        // Utilisation de import dynamique
+        const module = await Promise.resolve(`${fullPath}`).then(s => __importStar(require(s)));
+        // On suppose que la collection exporte toujours une const (ex: Posts)
+        for (const exported of Object.values(module)) {
+            const col = exported;
+            if (col?.slug && col?.fields) {
+                collections.push(col);
+            }
+        }
+    }
+    return collections;
+};
+exports.loadCollections = loadCollections;
+// Exemple d'utilisation
+(async () => {
+    const collections = await (0, exports.loadCollections)();
+    (0, generate_1.generateShadowSchema)(collections);
+    console.log(`[worker] Shadow schema generated for ${collections.length} collections.`);
+})();

package/package.json

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