@deessejs/collections 0.0.22 → 0.0.24

package/dist/collections/define.d.ts

@@ -1,32 +1,2 @@
 import { Collection } from "./types";
-export declare const collection: <const Slug extends string, const Fields extends Record<string, any>>(config: {
-    slug: Slug;
-    name?: string;
-    admin?: {
-        title?: string;
-        group?: string;
-    };
-    fields: Fields;
-    hooks?: Collection["hooks"];
-    permissions?: {
-        create?: (ctx: any) => Promise<boolean>;
-        read?: (ctx: any) => Promise<boolean>;
-        update?: (ctx: any) => Promise<boolean>;
-        delete?: (ctx: any) => Promise<boolean>;
-    };
-}) => {
-    slug: Slug;
-    name?: string;
-    admin?: {
-        title?: string;
-        group?: string;
-    };
-    fields: Fields;
-    hooks?: Collection["hooks"];
-    permissions?: {
-        create?: (ctx: any) => Promise<boolean>;
-        read?: (ctx: any) => Promise<boolean>;
-        update?: (ctx: any) => Promise<boolean>;
-        delete?: (ctx: any) => Promise<boolean>;
-    };
-};
+export declare const collection: <const Slug extends string, const Fields extends Record<string, any>>(config: Collection<Slug, Fields>) => Collection<Slug, Fields>;

package/dist/config/index.d.ts

@@ -1,16 +1,8 @@
-import { Collection } from "../collections/types";
-import { Field, FieldTypeFinal } from "../fields/types";
-import { Provider } from "../providers/types";
-type InferSchema<F extends Record<string, Field>> = {
-    [K in keyof F]: F[K] extends Field<infer FT> ? FT extends FieldTypeFinal<any, infer TVal> ? TVal : never : never;
-};
-export declare const defineConfig: <const C extends {
-    provider: Provider;
-    collections: readonly Collection[];
-}>(config: C) => { [Col in C["collections"][number] as Col["slug"]]: {
+import { InferSchema } from "../fields/types";
+import { Config } from "./types";
+export declare const defineConfig: <const C extends Config>(config: C) => { [Col in C["collections"][number] as Col["slug"]]: {
     create: (data: InferSchema<Col["fields"]>) => Promise<any>;
     read: (id: string) => Promise<any>;
     update: (id: string, data: Partial<InferSchema<Col["fields"]>>) => Promise<any>;
     delete: (id: string) => Promise<void>;
 }; };
-export {};

package/dist/config/index.js

@@ -1,15 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defineConfig = void 0;
+const orchestrator_1 = require("./orchestrator");
 const defineConfig = (config) => {
-    config.provider.init();
+    // 1. Initialisation du Provider (Création tables, connexion DB...)
+    // On passe les collections pour qu'il connaisse le schéma
+    config.provider.init(config.collections);
     const db = {};
+    // 2. Construction dynamique de l'objet DB
     for (const col of config.collections) {
         db[col.slug] = {
-            create: async (data) => data,
-            read: async (id) => ({ id }),
-            update: async (id, data) => ({ id, ...data }),
-            delete: async (id) => { },
+            create: async (data) => {
+                return (0, orchestrator_1.runOperation)("create", col, config.provider, { data });
+            },
+            read: async (id) => {
+                return (0, orchestrator_1.runOperation)("read", col, config.provider, { id });
+            },
+            update: async (id, data) => {
+                return (0, orchestrator_1.runOperation)("update", col, config.provider, { id, data });
+            },
+            delete: async (id) => {
+                return (0, orchestrator_1.runOperation)("delete", col, config.provider, { id });
+            },
         };
     }
     return db;

package/dist/config/orchestrator.d.ts

@@ -0,0 +1,8 @@
+import { Collection } from "../collections/types";
+import { Provider } from "../providers/types";
+type Action = 'create' | 'read' | 'update' | 'delete';
+export declare const runOperation: (action: Action, collection: Collection, provider: Provider, payload: {
+    id?: string;
+    data?: any;
+}) => Promise<any>;
+export {};

package/dist/config/orchestrator.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runOperation = void 0;
+const runOperation = async (action, collection, provider, payload) => {
+    const { hooks } = collection;
+    let currentData = payload.data;
+    const id = payload.id;
+    try {
+        // 1. Hook Global: beforeOperation
+        if (hooks?.beforeOperation) {
+            await hooks.beforeOperation({ action, collection: collection.slug, data: currentData, id });
+        }
+        // 2. Hook Spécifique: before[Action]
+        // Note: TypeScript peut être strict ici, on simplifie pour la demo
+        if (action === 'create' && hooks?.beforeCreate)
+            currentData = await hooks.beforeCreate(currentData);
+        if (action === 'update' && hooks?.beforeUpdate)
+            currentData = await hooks.beforeUpdate(currentData);
+        if (action === 'delete' && hooks?.beforeDelete)
+            await hooks.beforeDelete({ id });
+        // 3. APPEL AU PROVIDER (Le vrai travail DB)
+        let result;
+        switch (action) {
+            case 'create':
+                result = await provider.create(collection.slug, currentData);
+                break;
+            case 'read':
+                if (!id)
+                    throw new Error("ID required for read");
+                result = await provider.read(collection.slug, id);
+                break;
+            case 'update':
+                if (!id)
+                    throw new Error("ID required for update");
+                result = await provider.update(collection.slug, id, currentData);
+                break;
+            case 'delete':
+                if (!id)
+                    throw new Error("ID required for delete");
+                await provider.delete(collection.slug, id);
+                result = { success: true, id };
+                break;
+        }
+        // 4. Hook Spécifique: after[Action]
+        if (action === 'create' && hooks?.afterCreate)
+            result = await hooks.afterCreate(result);
+        if (action === 'update' && hooks?.afterUpdate)
+            result = await hooks.afterUpdate(result);
+        if (action === 'delete' && hooks?.afterDelete)
+            result = await hooks.afterDelete(result);
+        // 5. Hook Global: afterOperation
+        if (hooks?.afterOperation) {
+            await hooks.afterOperation({ action, result });
+        }
+        // 6. Hook Global: afterSuccess (spécifique à ta liste)
+        if (hooks?.afterSuccess) {
+            await hooks.afterSuccess(result);
+        }
+        return result;
+    }
+    catch (error) {
+        // Gestion des erreurs via les hooks
+        if (hooks?.afterError) {
+            // Le hook peut transformer l'erreur ou la logger
+            await hooks.afterError(error);
+        }
+        throw error; // On relance l'erreur pour que l'appelant sache que ça a échoué
+    }
+};
+exports.runOperation = runOperation;

package/dist/config/types.d.ts

@@ -1,7 +1,15 @@
 import { Collection } from "../collections/types";
 import { CollectionsCrud } from "../database/types";
+import { Field, FieldTypeFinal } from "../fields";
+import { Plugin } from "../plugins/types";
+import { Provider } from "../providers/types";
 import { UnionToIntersection } from "../utils/union-intersection";
 export type Config = {
-    collections: Collection[];
+    provider: Provider;
+    readonly collections: Collection[];
+    plugins?: Plugin[];
 };
 export type DbFromConfig<C extends Config> = UnionToIntersection<CollectionsCrud<C["collections"][number]>>;
+export type InferSchema<F extends Record<string, Field>> = {
+    [K in keyof F]: F[K] extends Field<infer FT> ? FT extends FieldTypeFinal<any, infer TVal> ? TVal : never : never;
+};

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-export * from './config';
-export * from './collections';
-export * from './fields';
-export * from './providers';
+export * from "./config";
+export * from "./collections";
+export * from "./fields";
+export * from "./providers";
+export * from "./plugins";

package/dist/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./config"), exports);
 __exportStar(require("./collections"), exports);
 __exportStar(require("./fields"), exports);
 __exportStar(require("./providers"), exports);
+__exportStar(require("./plugins"), exports);

package/dist/plugins/index.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from "./types";
+export declare const plugin: () => Plugin;

package/dist/plugins/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const plugin = () => {
+    return {};
+};
+exports.plugin = plugin;

package/dist/plugins/types.d.ts

@@ -0,0 +1 @@
+export type Plugin = {};

package/dist/plugins/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/providers/index.js

@@ -2,9 +2,55 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.inAppProvider = void 0;
 const inAppProvider = () => {
+    // Stockage en mémoire : { "posts": { "id_1": { ...data }, "id_2": { ...data } } }
+    const storage = {};
     return {
-        init: () => {
+        // L'init reçoit maintenant la liste des collections pour préparer le "schéma"
+        init: (collections) => {
             console.log("Initializing in-app provider");
+            for (const col of collections) {
+                // On initialise un "bucket" vide pour chaque collection si pas déjà fait
+                if (!storage[col.slug]) {
+                    storage[col.slug] = {};
+                }
+            }
+        },
+        create: async (collectionSlug, data) => {
+            // Simulation d'un ID (dans une vraie DB, c'est géré par le moteur ou UUID)
+            const id = Math.random().toString(36).substring(2, 15);
+            const record = { ...data, id };
+            // Sécurité au cas où on écrit dans une collection non initialisée
+            if (!storage[collectionSlug])
+                storage[collectionSlug] = {};
+            storage[collectionSlug][id] = record;
+            return record;
+        },
+        read: async (collectionSlug, id) => {
+            const record = storage[collectionSlug]?.[id];
+            if (!record) {
+                throw new Error(`Record with ID "${id}" not found in "${collectionSlug}".`);
+            }
+            return record;
+        },
+        update: async (collectionSlug, id, data) => {
+            const existing = storage[collectionSlug]?.[id];
+            if (!existing) {
+                throw new Error(`Cannot update: Record with ID "${id}" not found in "${collectionSlug}".`);
+            }
+            // Fusion des données (Partial update)
+            const updated = { ...existing, ...data };
+            storage[collectionSlug][id] = updated;
+            return updated;
+        },
+        delete: async (collectionSlug, id) => {
+            if (storage[collectionSlug] && storage[collectionSlug][id]) {
+                delete storage[collectionSlug][id];
+            }
+            else {
+                // Optionnel : Throw une erreur si l'item n'existe pas, 
+                // ou juste ignorer comme le ferait une requête SQL "DELETE WHERE ID=..."
+                console.warn(`Attempted to delete non-existent record "${id}" in "${collectionSlug}"`);
+            }
         }
     };
 };

package/dist/providers/types.d.ts

@@ -1,3 +1,8 @@
+import { Collection } from "../collections/types";
 export type Provider = {
-    init: () => void;
+    init: (collections: readonly Collection[]) => Promise<void> | void;
+    create: (collectionSlug: string, data: any) => Promise<any>;
+    read: (collectionSlug: string, id: string) => Promise<any>;
+    update: (collectionSlug: string, id: string, data: any) => Promise<any>;
+    delete: (collectionSlug: string, id: string) => Promise<void>;
 };

package/package.json

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