@deessejs/collections 0.0.41 → 0.0.42

package/dist/esm/collections/define.d.ts

@@ -0,0 +1,43 @@
+import { Field } from "../fields";
+import { Collection } from "./types";
+export declare const collection: <const Slug extends string, const Fields extends Record<string, Field>>(config: Collection<Slug, Fields>) => Collection<Slug, Fields & {
+    readonly id: Field<{
+        kind: import("../fields").FieldKind;
+        params: unknown;
+        dsl: {
+            kind: import("../fields").FieldKind;
+            isPrimary: boolean;
+            isUnique: boolean;
+            canBeNull: boolean;
+        };
+        admin: {
+            component: any;
+        };
+    }>;
+    readonly createdAt: import("../fields").FieldChain<{
+        kind: import("../fields").FieldKind;
+        params: unknown;
+        dsl: {
+            kind: import("../fields").FieldKind;
+            isPrimary: boolean;
+            isUnique: boolean;
+            canBeNull: boolean;
+        };
+        admin: {
+            component: any;
+        };
+    }>;
+    readonly updatedAt: import("../fields").FieldChain<{
+        kind: import("../fields").FieldKind;
+        params: unknown;
+        dsl: {
+            kind: import("../fields").FieldKind;
+            isPrimary: boolean;
+            isUnique: boolean;
+            canBeNull: boolean;
+        };
+        admin: {
+            component: any;
+        };
+    }>;
+}>;

package/dist/esm/collections/define.js

@@ -0,0 +1,9 @@
+import { field, primary, serial, timestamp } from "../fields";
+import { extendFields } from "./extend-fields";
+export const collection = (config) => {
+    return extendFields(config, {
+        id: primary(field({ type: serial() })),
+        createdAt: field({ type: timestamp() }),
+        updatedAt: field({ type: timestamp() }),
+    });
+};

package/dist/esm/collections/extend-fields.d.ts

@@ -0,0 +1,3 @@
+import { Field } from "../fields";
+import { Collection } from "./types";
+export declare const extendFields: <const Slug extends string, const Fields extends Record<string, Field>, const NewFields extends Record<string, Field>>(base: Collection<Slug, Fields>, newFields: NewFields) => Collection<Slug, Fields & NewFields>;

package/dist/esm/collections/extend-fields.js

@@ -0,0 +1,9 @@
+export const extendFields = (base, newFields) => {
+    return {
+        ...base,
+        fields: {
+            ...base.fields,
+            ...newFields,
+        },
+    };
+};

package/dist/esm/collections/index.d.ts

@@ -0,0 +1 @@
+export * from './define';

package/dist/esm/collections/index.js

@@ -0,0 +1 @@
+export * from './define';

package/dist/esm/collections/types.d.ts

@@ -0,0 +1,29 @@
+import { Field } from "../fields";
+export type CollectionHooks = {
+    beforeCreate?: (data: any) => Promise<any>;
+    afterCreate?: (data: any) => Promise<any>;
+    beforeUpdate?: (data: any) => Promise<any>;
+    afterUpdate?: (data: any) => Promise<any>;
+    beforeDelete?: (data: any) => Promise<any>;
+    afterDelete?: (data: any) => Promise<any>;
+    beforeOperation?: (data: any) => Promise<any>;
+    afterOperation?: (data: any) => Promise<any>;
+    afterError?: (error: Error) => Promise<any>;
+    afterSuccess?: (data: any) => Promise<any>;
+};
+export type Collection<Slug extends string = string, Fields extends Record<string, Field> = Record<string, Field>> = {
+    slug: Slug;
+    name?: string;
+    admin?: {
+        title?: string;
+        group?: string;
+    };
+    fields: Fields;
+    hooks?: CollectionHooks;
+    permissions?: {
+        create?: (ctx: any) => Promise<boolean>;
+        read?: (ctx: any) => Promise<boolean>;
+        update?: (ctx: any) => Promise<boolean>;
+        delete?: (ctx: any) => Promise<boolean>;
+    };
+};

package/dist/esm/collections/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/config/index.d.ts

@@ -0,0 +1,5 @@
+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/esm/config/index.js

@@ -0,0 +1,13 @@
+import { drizzle } from "drizzle-orm/node-postgres";
+let _config;
+export const defineConfig = (config) => {
+    _config = config;
+    const db = drizzle(config.databaseUrl);
+    return db;
+};
+export const waitConfig = async () => {
+    while (!_config) {
+        await new Promise((r) => setTimeout(r, 50));
+    }
+    return _config;
+};

package/dist/esm/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/esm/config/orchestrator.js

@@ -0,0 +1,66 @@
+export 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é
+    }
+};

package/dist/esm/config/types.d.ts

@@ -0,0 +1,14 @@
+import { Collection } from "../collections/types";
+import { CollectionsCrud } from "../database/types";
+import { Field, FieldTypeFinal } from "../fields";
+import { Plugin } from "../plugins/types";
+import { UnionToIntersection } from "../utils/union-intersection";
+export type Config = {
+    databaseUrl: string;
+    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/esm/config/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/database/types.d.ts

@@ -0,0 +1,10 @@
+import { Collection } from "../collections/types";
+import { InferSchema } from "../fields/types";
+export type CollectionsCrud<C extends Collection> = {
+    [K in C["slug"]]: {
+        create: (data: InferSchema<C["fields"]>) => Promise<any>;
+        read: (id: string) => Promise<any>;
+        update: (id: string, data: Partial<InferSchema<C["fields"]>>) => Promise<any>;
+        delete: (id: string) => Promise<void>;
+    };
+};

package/dist/esm/database/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/drizzle/generate.d.ts

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

package/dist/esm/drizzle/generate.js

@@ -0,0 +1,30 @@
+import fs from "fs";
+import path from "path";
+import { DrizzleTypes } from ".";
+const SHADOW_DIR = path.join(process.cwd(), ".deesse", "shadow");
+const SCHEMA_PATH = path.join(SHADOW_DIR, "schema.ts");
+export const generateShadowSchema = (collections) => {
+    fs.mkdirSync(SHADOW_DIR, { recursive: true });
+    const tablesCode = collections.map((col) => {
+        const columns = Object.entries(col.fields)
+            .map(([name, field]) => {
+            const kind = field.type.dsl.kind;
+            const drizzleType = Object.keys(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.writeFileSync(SCHEMA_PATH, schemaFileContent);
+    console.log("[Deesse] Shadow schema generated at", SCHEMA_PATH);
+};

package/dist/esm/drizzle/index.d.ts

@@ -0,0 +1,31 @@
+import { Collection } from "../collections/types";
+import { FieldKind } from "../fields";
+export declare const DrizzleTypes: Record<FieldKind, () => any>;
+export declare const toDrizzle: (collection: Collection) => import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: string;
+    schema: undefined;
+    columns: {
+        [x: string]: import("drizzle-orm/pg-core").PgColumn<{
+            name: any;
+            tableName: string;
+            dataType: any;
+            columnType: any;
+            data: any;
+            driverParam: any;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: any;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            [x: string]: any;
+            [x: number]: any;
+            [x: symbol]: any;
+        }>;
+    };
+    dialect: "pg";
+}>;

package/dist/esm/drizzle/index.js

@@ -0,0 +1,20 @@
+import { boolean, integer, serial, text, varchar, char, numeric, decimal, json, uuid, timestamp, pgTable, } from "drizzle-orm/pg-core";
+export const DrizzleTypes = {
+    boolean: () => boolean(),
+    integer: () => integer(),
+    serial: () => serial(),
+    text: () => text(),
+    varchar: () => varchar(),
+    char: () => char(),
+    numeric: () => numeric(),
+    decimal: () => decimal(),
+    json: () => json(),
+    uuid: () => uuid(),
+    timestamp: () => timestamp(),
+};
+export const toDrizzle = (collection) => {
+    return pgTable(collection.slug, Object.fromEntries(Object.entries(collection.fields).map(([name, field]) => {
+        const kind = field.type.dsl.kind;
+        return [name, DrizzleTypes[kind]()];
+    })));
+};

package/dist/esm/drizzle/types.js

@@ -0,0 +1 @@
+"use strict";

package/dist/esm/dsl/collections.d.ts

@@ -0,0 +1,13 @@
+import { Collection } from "../collections/types";
+export declare const dsl: (collection: Collection) => {
+    slug: string;
+    fields: {
+        name: string;
+        dsl: {
+            kind: string;
+            isPrimary: boolean;
+            isUnique: boolean;
+            canBeNull: boolean;
+        };
+    }[];
+};

package/dist/esm/dsl/collections.js

@@ -0,0 +1,10 @@
+export const dsl = (collection) => {
+    const { slug, fields } = collection;
+    return {
+        slug,
+        fields: Object.entries(fields).map(([name, field]) => ({
+            name,
+            dsl: field.type.dsl,
+        })),
+    };
+};

package/dist/esm/dsl/index.d.ts

@@ -0,0 +1 @@
+export * from './collections';

package/dist/esm/dsl/index.js

@@ -0,0 +1 @@
+export * from './collections';

package/dist/esm/fields/constraints.d.ts

@@ -0,0 +1,6 @@
+import { Field, FieldChain, FieldTypeFinal } from "./types";
+export declare const unique: <TType extends FieldTypeFinal>(field: Field<TType>) => Field<TType>;
+export declare const required: <TType extends FieldTypeFinal>(field: Field<TType>) => Field<TType>;
+export declare const optional: <TType extends FieldTypeFinal>(field: Field<TType>) => Field<TType>;
+export declare const primary: <TType extends FieldTypeFinal>(field: Field<TType>) => Field<TType>;
+export declare const attachChain: <TType extends FieldTypeFinal>(f: Field<TType>) => FieldChain<TType>;

package/dist/esm/fields/constraints.js

@@ -0,0 +1,59 @@
+export const unique = (field) => {
+    return {
+        ...field,
+        type: {
+            ...field.type,
+            dsl: {
+                ...field.type.dsl,
+                isUnique: true,
+            },
+        },
+    };
+};
+export const required = (field) => ({
+    ...field,
+    type: {
+        ...field.type,
+        dsl: {
+            ...field.type.dsl,
+            canBeNull: false,
+        },
+    },
+});
+export const optional = (field) => ({
+    ...field,
+    type: {
+        ...field.type,
+        dsl: {
+            ...field.type.dsl,
+            canBeNull: true,
+        },
+    },
+});
+export const primary = (field) => ({
+    ...field,
+    type: {
+        ...field.type,
+        dsl: {
+            ...field.type.dsl,
+            isPrimary: true,
+        },
+    },
+});
+export const attachChain = (f) => {
+    return {
+        ...f,
+        unique() {
+            return attachChain(unique(f));
+        },
+        required() {
+            return attachChain(required(f));
+        },
+        optional() {
+            return attachChain(optional(f));
+        },
+        primary() {
+            return attachChain(primary(f));
+        },
+    };
+};

package/dist/esm/fields/core.d.ts

@@ -0,0 +1,71 @@
+export declare const number: (params?: {
+    min?: number | undefined;
+    max?: number | undefined;
+} | undefined) => {
+    kind: import("./types").FieldKind;
+    params: unknown;
+    dsl: {
+        kind: import("./types").FieldKind;
+        isPrimary: boolean;
+        isUnique: boolean;
+        canBeNull: boolean;
+    };
+    admin: {
+        component: any;
+    };
+};
+export declare const text: (params?: {
+    min?: number | undefined;
+    max?: number | undefined;
+} | undefined) => {
+    kind: import("./types").FieldKind;
+    params: unknown;
+    dsl: {
+        kind: import("./types").FieldKind;
+        isPrimary: boolean;
+        isUnique: boolean;
+        canBeNull: boolean;
+    };
+    admin: {
+        component: any;
+    };
+};
+export declare const uuid: (params?: void | undefined) => {
+    kind: import("./types").FieldKind;
+    params: unknown;
+    dsl: {
+        kind: import("./types").FieldKind;
+        isPrimary: boolean;
+        isUnique: boolean;
+        canBeNull: boolean;
+    };
+    admin: {
+        component: any;
+    };
+};
+export declare const timestamp: (params?: void | undefined) => {
+    kind: import("./types").FieldKind;
+    params: unknown;
+    dsl: {
+        kind: import("./types").FieldKind;
+        isPrimary: boolean;
+        isUnique: boolean;
+        canBeNull: boolean;
+    };
+    admin: {
+        component: any;
+    };
+};
+export declare const serial: (params?: void | undefined) => {
+    kind: import("./types").FieldKind;
+    params: unknown;
+    dsl: {
+        kind: import("./types").FieldKind;
+        isPrimary: boolean;
+        isUnique: boolean;
+        canBeNull: boolean;
+    };
+    admin: {
+        component: any;
+    };
+};

package/dist/esm/fields/core.js

@@ -0,0 +1,27 @@
+import z from "zod";
+import { fieldType } from "./field";
+export const number = fieldType({
+    schema: z.object({ min: z.number().optional(), max: z.number().optional() }),
+    dsl: { kind: "numeric" },
+    admin: { component: undefined },
+});
+export const text = fieldType({
+    schema: z.object({ min: z.number().optional(), max: z.number().optional() }),
+    dsl: { kind: "text" },
+    admin: { component: undefined },
+});
+export const uuid = fieldType({
+    schema: z.void(),
+    dsl: { kind: "uuid" },
+    admin: { component: undefined },
+});
+export const timestamp = fieldType({
+    schema: z.void(),
+    dsl: { kind: "timestamp" },
+    admin: { component: undefined },
+});
+export const serial = fieldType({
+    schema: z.void(),
+    dsl: { kind: "serial" },
+    admin: { component: undefined },
+});

package/dist/esm/fields/field.d.ts

@@ -0,0 +1,24 @@
+import z from "zod";
+import { FieldChain, FieldConfig, FieldKind, FieldTypeFinal } from "./types";
+export declare const fieldType: <TOutput, TParams extends z.ZodType | undefined>(config: {
+    schema?: TParams;
+    dsl: {
+        kind: FieldKind;
+    };
+    admin: {
+        component: any;
+    };
+}) => (params?: TParams extends z.ZodType ? z.infer<TParams> : undefined) => {
+    kind: FieldKind;
+    params: unknown;
+    dsl: {
+        kind: FieldKind;
+        isPrimary: boolean;
+        isUnique: boolean;
+        canBeNull: boolean;
+    };
+    admin: {
+        component: any;
+    };
+};
+export declare const field: <TType extends FieldTypeFinal>(config: FieldConfig<TType>) => FieldChain<TType>;

package/dist/esm/fields/field.js

@@ -0,0 +1,33 @@
+import { attachChain } from "./constraints";
+export const fieldType = (config) => (params) => {
+    const validated = config.schema && params !== undefined
+        ? config.schema.parse(params)
+        : params;
+    return {
+        kind: config.dsl.kind,
+        params: validated,
+        dsl: {
+            kind: config.dsl.kind,
+            isPrimary: false,
+            isUnique: false,
+            canBeNull: true,
+        },
+        admin: config.admin,
+    };
+};
+const defaultPermissions = {
+    create: async () => true,
+    read: async () => true,
+    update: async () => true,
+    delete: async () => true,
+};
+export const field = (config) => {
+    const base = {
+        type: config.type,
+        permissions: {
+            ...defaultPermissions,
+            ...config.permissions,
+        },
+    };
+    return attachChain(base);
+};

package/dist/esm/fields/index.d.ts

@@ -0,0 +1,4 @@
+export * from './field';
+export * from './types';
+export * from './core';
+export * from './constraints';

package/dist/esm/fields/index.js

@@ -0,0 +1,4 @@
+export * from './field';
+export * from './types';
+export * from './core';
+export * from './constraints';

package/dist/esm/fields/types.d.ts

@@ -0,0 +1,48 @@
+import { z } from "zod";
+export type FieldKind = "integer" | "serial" | "boolean" | "text" | "varchar" | "char" | "numeric" | "decimal" | "json" | "uuid" | "timestamp";
+export type FieldTypeConfig<TParams extends z.ZodType = z.ZodType> = {
+    schema?: TParams;
+    dsl: {
+        kind: FieldKind;
+    };
+    admin: {
+        component: any;
+    };
+};
+export type FieldTypeFinal<TParams extends z.ZodType = z.ZodType, TOutput = any> = {
+    kind: string;
+    params: z.infer<TParams>;
+    dsl: {
+        kind: string;
+        isPrimary: boolean;
+        isUnique: boolean;
+        canBeNull: boolean;
+    };
+    admin: {
+        component: any;
+    };
+    _output?: TOutput;
+};
+export type FieldPermissions = {
+    create: (ctx: any) => Promise<boolean>;
+    read: (ctx: any) => Promise<boolean>;
+    update: (ctx: any) => Promise<boolean>;
+    delete: (ctx: any) => Promise<boolean>;
+};
+export type FieldConfig<TType extends FieldTypeFinal> = {
+    type: TType;
+    permissions?: Partial<FieldPermissions>;
+};
+export type Field<TType extends FieldTypeFinal = FieldTypeFinal> = {
+    type: TType;
+    permissions: FieldPermissions;
+};
+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;
+};
+export type FieldChain<TType extends FieldTypeFinal> = Field<TType> & {
+    unique(): FieldChain<TType>;
+    required(): FieldChain<TType>;
+    optional(): FieldChain<TType>;
+    primary(): FieldChain<TType>;
+};

package/dist/esm/fields/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./collections";
+export * from "./config";
+export * from "./drizzle";
+export * from "./dsl";
+export * from "./fields";
+export * from "./next";
+export * from "./plugins";
+export * from "./providers";

package/dist/esm/index.js

@@ -0,0 +1,8 @@
+export * from "./collections";
+export * from "./config";
+export * from "./drizzle";
+export * from "./dsl";
+export * from "./fields";
+export * from "./next";
+export * from "./plugins";
+export * from "./providers";

package/dist/esm/next/index.d.ts

@@ -0,0 +1,5 @@
+import type { NextConfig } from "next";
+declare global {
+    var __collections_worker_started: boolean | undefined;
+}
+export declare const withCollections: (phase: string, config: NextConfig) => NextConfig;

package/dist/esm/next/index.js

@@ -0,0 +1,17 @@
+import { spawn } from "child_process";
+import { PHASE_DEVELOPMENT_SERVER } from "next/constants";
+import path from "path";
+export const withCollections = (phase, config) => {
+    const isDev = phase === PHASE_DEVELOPMENT_SERVER;
+    if (isDev && !global.__collections_worker_started) {
+        global.__collections_worker_started = true;
+        const workerPath = path.join(__dirname, "../worker/index.js");
+        console.log("[withCollections] Spawning background worker:", workerPath);
+        spawn("node", [workerPath], {
+            stdio: "inherit",
+        });
+    }
+    return {
+        ...config,
+    };
+};

package/dist/esm/plugins/index.d.ts

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

package/dist/esm/plugins/index.js

@@ -0,0 +1,3 @@
+export const plugin = () => {
+    return {};
+};

package/dist/esm/plugins/types.d.ts

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

package/dist/esm/plugins/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/providers/index.d.ts

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

package/dist/esm/providers/index.js

@@ -0,0 +1,53 @@
+export const inAppProvider = () => {
+    // Stockage en mémoire : { "posts": { "id_1": { ...data }, "id_2": { ...data } } }
+    const storage = {};
+    return {
+        // 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/esm/providers/types.d.ts

@@ -0,0 +1,8 @@
+import { Collection } from "../collections/types";
+export type Provider = {
+    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/dist/esm/providers/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/utils/deep-partial.d.ts

@@ -0,0 +1,3 @@
+export type DeepPartial<T> = T extends (infer U)[] ? DeepPartial<U>[] : T extends object ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : T;

package/dist/esm/utils/deep-partial.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/utils/exact.d.ts

@@ -0,0 +1 @@
+type Exact<A, B> = A extends B ? Exclude<keyof A, keyof B> extends never ? A : never : never;

package/dist/esm/utils/exact.js

@@ -0,0 +1 @@
+"use strict";

package/dist/esm/utils/union-intersection.d.ts

@@ -0,0 +1 @@
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;

package/dist/esm/utils/union-intersection.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/worker/index.d.ts

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

package/dist/esm/worker/index.js

@@ -0,0 +1,32 @@
+import fs from "fs";
+import path from "path";
+import { generateShadowSchema } from "../drizzle/generate";
+// Dossier des collections
+const collectionsDir = path.join(process.cwd(), "src", "collections");
+console.log(`[worker] Loading collections from ${collectionsDir}`);
+// Fonction pour importer toutes les collections
+export const loadCollections = async () => {
+    const files = fs
+        .readdirSync(collectionsDir)
+        .filter((f) => f.endsWith(".ts") || f.endsWith(".js"));
+    const collections = [];
+    for (const file of files) {
+        const fullPath = path.join(collectionsDir, file);
+        // Utilisation de import dynamique
+        const module = await import(fullPath);
+        // 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;
+};
+// Exemple d'utilisation
+(async () => {
+    const collections = await loadCollections();
+    generateShadowSchema(collections);
+    console.log(`[worker] Shadow schema generated for ${collections.length} collections.`);
+})();

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@deessejs/collections",
-  "version": "0.0.41",
+  "version": "0.0.42",
   "description": "",
-  "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "module": "dist/index.esm.js",
+  "main": "dist/index.js",
+  "module": "dist/esm/index.js",
   "exports": {
     ".": {
-      "import": "./dist/index.esm.js",
+      "import": "./dist/esm/index.js",
       "require": "./dist/index.js",
       "types": "./dist/index.d.ts"
     }
@@ -18,7 +18,6 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "tsc",
     "build:watch": "tsc --watch",
     "prepublishOnly": "npm run build",
     "lint": "eslint src --ext .ts",
@@ -27,7 +26,10 @@
     "test:ui": "vitest --ui",
     "test:run": "vitest run",
     "test:coverage": "vitest run --coverage",
-    "test:watch": "vitest watch"
+    "test:watch": "vitest watch",
+    "build:cjs": "tsc --project tsconfig.json",
+    "build:esm": "tsc --project tsconfig.esm.json",
+    "build": "npm run build:cjs && npm run build:esm"
   },
   "repository": {
     "type": "git",