@anteros/core 0.0.1-alpha.1

package/types/file.d.ts

@@ -0,0 +1,120 @@
+import type { AppError, fn } from "../lib/error";
+import type { Field } from "./field";
+import type { HooksCollection } from "./hook";
+import type Joi from "joi";
+import type { useRest } from "../database/rest";
+import type { jwt } from "../utils/func";
+
+type FileAccessHandler = (ctx: {
+    rest: InstanceType<typeof useRest>;
+    error: typeof fn.error;
+    jwt: typeof jwt;
+    token: { value: string | null; decoded: Record<string, unknown> | null; provided: boolean; expired: boolean };
+}) => boolean | Promise<boolean>;
+
+type FileApiAccess = {
+    /** Access control for POST /upload/:tenant_id/:slug */
+    upload?: boolean | FileAccessHandler;
+    /** Access control for GET /files/:tenant_id/:slug/:file */
+    read?: boolean | FileAccessHandler;
+    /** Access control for DELETE /files/:tenant_id/:slug/:file */
+    delete?: boolean | FileAccessHandler;
+};
+
+/**
+ * File collection type.
+ *
+ * Defined in `files/*.file.ts` — a dedicated collection
+ * for handling file uploads, storage, and serving.
+ *
+ * Each file collection generates:
+ *   POST   /upload/:tenant_id/:slug       — upload a file
+ *   GET    /files/:tenant_id/:slug/:file  — serve/download a file
+ */
+export type FileCollection = {
+    /** Unique identifier used in routes: `/upload/:tenant_id/:slug` */
+    slug: string;
+    hooks?: {
+        beforeOperation?: HooksCollection['beforeOperation'];
+        afterOperation?: HooksCollection['afterOperation'];
+    };
+    /** Metadata fields stored alongside the file document */
+    fields?: Field[];
+    /** Upload validation rules */
+    upload?: {
+        /** Allowed MIME types for upload.
+         * @example ['image/jpeg', 'image/png', 'application/pdf'] */
+        allowedMimeTypes?: string[];
+        /** Maximum file size in bytes. Default: 10MB */
+        maxSize?: number;
+        /**
+         * Image transformations (resize, format, etc.).
+         * Applied on-the-fly when serving via GET /files/:tenant_id/:slug/:file
+         */
+        transformations?: {
+            /** Resize to max width in pixels */
+            width?: number;
+            /** Resize to max height in pixels */
+            height?: number;
+            /** Output format */
+            format?: 'webp' | 'jpeg' | 'png' | 'avif';
+            /** Quality 1-100 (default: 80) */
+            quality?: number;
+        };
+    };
+    /**
+     * Storage configuration.
+     * @default 'disk'
+     */
+    storage?: {
+        /** Storage backend */
+        driver: 'disk' | 's3';
+        /** Relative path inside the tenant storage directory.
+         * @example 'uploads/photos' */
+        path?: string;
+        /** S3 bucket name (required if driver is 's3') */
+        bucket?: string;
+        /** S3 region (required if driver is 's3') */
+            region?: string;
+        };
+        /**
+         * Replicate uploaded files to remote destinations.
+         * Executed after the primary storage save.
+         */
+        replicate?: {
+            /** Destination driver */
+            driver: 's3' | 'ssh' | 'sftp';
+            /** Remote host (required for ssh/sftp) */
+            host?: string;
+            /** SSH/SFTP port (default: 22) */
+            port?: number;
+            /** Remote username (required for ssh/sftp) */
+            username?: string;
+            /** Remote path or directory */
+            path?: string;
+            /** S3 bucket (required if driver is 's3') */
+            bucket?: string;
+            /** S3 region */
+            region?: string;
+            /** Custom S3 endpoint */
+            endpoint?: string;
+            /** Private key path for SSH auth */
+            privateKey?: string;
+        }[];
+        /** Enregistrer les métadonnées du fichier en base. Défaut: true */
+        trackMetaData?: boolean;
+    api?: {
+        access?: FileApiAccess;
+        privateFields?: (string | RegExp)[];
+        readOnlyFields?: (string | RegExp)[];
+    };
+    /**
+     * The tenant id of the file collection
+     * @type {string}
+     */
+    _tenant_?: string;
+    _isTimeSerie_?: boolean;
+    _isFileCollection_?: boolean;
+    _schema_?: Joi.Schema;
+    _schemaPartial_?: Joi.Schema;
+}

package/types/hook.d.ts

@@ -0,0 +1,30 @@
+import type { MongoRest } from "../database/mongodbadapter";
+import type { Server as SocketIO } from "socket.io";
+import type { ActionsApiList } from "./api";
+type metaHook = {
+    action: ActionsApiList;
+    collection: string;
+    data?: any;
+    params?: any;
+    ids?: string[];
+    filter?: object;
+    id?: string;
+    update?: any;
+    result?: any;
+    pipeline?: any[];
+    options?: any;
+}
+export type HooksCollection = {
+    beforeOperation?: (ctx: {
+        rest: MongoRest;
+        action: ActionsApiList;
+        meta: metaHook;
+        io: SocketIO;
+    }) => Promise<void>;
+    afterOperation?: (ctx: {
+        rest: MongoRest;
+        action: ActionsApiList;
+        meta: metaHook;
+        io: SocketIO;
+    }) => Promise<void>;
+}

package/types/middleware.d.ts

@@ -0,0 +1,18 @@
+import type { Context, Next } from "hono";
+
+export type TenantMiddlewareHandler = (c: Context, next: Next) => Promise<void | Response>;
+
+export type TenantMiddlewareConfig = {
+  name: string;
+  enabled?: boolean;
+  handler: TenantMiddlewareHandler;
+  _isTenantMiddleware_?: boolean;
+  _tenant_?: string;
+};
+
+export type GlobalMiddlewareConfig = {
+  name: string;
+  enabled?: boolean;
+  handler: TenantMiddlewareHandler;
+  _isGlobalMiddleware_?: boolean;
+};

package/types/mongo.d.ts

@@ -0,0 +1,61 @@
+import type { UpdateOptions } from "mongodb"
+
+export type updateOptions = UpdateOptions & {
+
+
+}
+
+
+export type FindOptions = {
+    $match?: {
+        _id?: string;
+        [key: string]: any;
+    };
+    $skip?: number;
+    $limit?: number;
+    $include?: Array<string | LookupOptions>;
+    $lookup?: Array<Record<string, any>>;
+    $graphLookup?: Array<Record<string, any>>;
+    $sort?: {
+        [key: string]: 1 | -1;
+    }
+    $project?: Record<string, unknown>;
+
+
+    $group?: {
+        _id: string;
+        [key: string]: any;
+    };
+    $sample?: {
+        size: number;
+    };
+    $sortAfterInclude?: object;
+    $projectAfterInclude?: object;
+    $matchAfterInclude?: object;
+    $unwind?: Array<string | {
+        path: string;
+        preserveNullAndEmptyArrays?: boolean;
+        includeArrayIndex?: string;
+    }>;
+}
+
+export type findOneByIdOptions = {
+    $include?: Array<string | LookupOptions>;
+    $matchAfterInclude?: object;
+}
+
+export type findOneOptions = {
+    $include?: Array<string | LookupOptions>;
+    /** Aligné sur `FindOptions.$project` pour les agrégations findOne (buildPipeline). */
+    $project?: Record<string, unknown>;
+}
+
+export type LookupOptions = {
+    from: string;
+    localField: string;
+    foreignField: string;
+    as?: string;
+    pipeline?: Array<any>;
+    let?: Record<string, any>;
+    unwind?: boolean;
+}

package/types/options.d.ts

@@ -0,0 +1,7 @@
+type LookupOptions = {
+    from: string;
+    localField: string;
+    foreignField: string;
+    as?: string;
+    pipeline?: Array<any>;
+}

package/types/rest.d.ts

@@ -0,0 +1,18 @@
+import type { UpdateOneModel, UpdateManyModel, ClientSession, MongoClientOptions } from "mongodb";
+
+export type RestActions =
+    'insertOne' | 'insertMany' | 'updateOne' | 'updateMany' | 'replaceOne' | 'deleteOne' | 'deleteMany'
+
+export type BulkUpdateOperation = { updateOne: UpdateOneModel } | { updateMany: UpdateManyModel };
+
+export type RestOptions = {
+    internal?: boolean;
+    tenant_id?: string;
+    useHook?: boolean;
+    useCustomApi?: boolean;
+    session?: ClientSession | null | undefined;
+    database?: {
+        uri: string;
+        options?: MongoClientOptions;
+    };
+}

package/types/route.d.ts

@@ -0,0 +1,19 @@
+import type { Context } from "hono";
+import type { useRest } from "../database/rest";
+
+type routeContext = {
+    rest: InstanceType<typeof useRest>;
+    jwt: typeof jwt;
+    io: InstanceType<typeof IO>;
+    c: Context
+}
+
+type Route = {
+    enabled?: boolean;
+    path: string;
+    method: 'GET' | 'POST';
+    handler: (ctx: routeContext) => void;
+    _tenant_?: string;
+    _isRoute_?: boolean;
+    _prefix_?: string;
+}

package/types/scripts.d.ts

@@ -0,0 +1,10 @@
+import { useRest } from "../database/rest"
+
+
+export type Script = {
+    _isScript_?: boolean;
+    enabled: boolean;
+    exec: (ctx: {
+        rest: InstanceType<typeof useRest>
+    }) => void
+}

package/types/service.d.ts

@@ -0,0 +1,37 @@
+import type { Server as SocketIO } from "socket.io";
+import type { useRest } from "../database/rest";
+import type { fn } from "../lib/error";
+import type { jwt } from "../utils/func";
+
+export type Service = {
+    _isService_?: boolean;
+    _tenant_?: string;
+    name: string;
+    enabled: boolean;
+    api?: {
+        access?: {
+            '*'?: ((ctx: {
+                rest: InstanceType<typeof useRest>;
+                error: typeof fn.error;
+                jwt: typeof jwt;
+                token: { value: string | null; decoded: Record<string, unknown> | null; provided: boolean; expired: boolean };
+            }) => Promise<boolean> | boolean) | boolean;
+            [key: string]: ((ctx: {
+                rest: InstanceType<typeof useRest>;
+                error: typeof fn.error;
+                jwt: typeof jwt;
+                token: { value: string | null; decoded: Record<string, unknown> | null; provided: boolean; expired: boolean };
+            }) => Promise<boolean> | boolean) | boolean;
+        };
+    };
+    actions: {
+        [key: string]: (ctx: {
+            data: any;
+            token: { value: string | null; decoded: Record<string, unknown> | null; provided: boolean; expired: boolean };
+            jwt: typeof jwt;
+            error: typeof fn.error;
+            io: SocketIO;
+            rest: InstanceType<typeof useRest>
+        }) => Promise<any>
+    }
+}

package/types/task.d.ts

@@ -0,0 +1,12 @@
+import type { io } from "../server/io";
+import type { useRest } from "../database/rest";
+
+export type Task = {
+    name: string;
+    pattern: string;
+    enabled: boolean;
+    exec: (ctx: {
+        io: InstanceType<typeof io>;
+        rest: InstanceType<typeof useRest>
+    }) => void
+}

package/types/tenant.d.ts

@@ -0,0 +1,16 @@
+import type { Db, MongoClient, MongoClientOptions } from "mongodb";
+export type Tenant = {
+    id: string;
+    name?: string;
+    description?: string;
+    dir: string;
+    routes?: {
+        prefix?: string;
+    },
+    database: {
+        uri: string;
+        options?: MongoClientOptions;
+        db?: Db;
+        client?: MongoClient;
+    }
+}

package/types/token.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Token information available in request context and handlers.
+ * Always present (even without a token — use `provided` to check).
+ */
+export type Token = {
+  /** Raw JWT string from the `Authorization` header, or null if not sent */
+  value: string | null;
+  /** Verified payload (claims), or null if invalid / expired / not sent */
+  decoded: Record<string, unknown> | null;
+  /** Whether a token was provided in the Authorization header */
+  provided: boolean;
+  /** Whether the token is expired */
+  expired: boolean;
+};

package/types/websocket.d.ts

@@ -0,0 +1,15 @@
+import type { Server as SocketIO, Socket as SocketClient } from "socket.io";
+import type { useRest } from "../database/rest";
+
+
+
+export type WebSocketHandler = {
+    _isWebSocket_?: boolean;
+    _tenant_?: string;
+    enabled: boolean;
+    exec: (ctx: {
+        io: SocketIO;
+        socket: SocketClient;
+        rest: InstanceType<typeof useRest>;
+    }) => void | Promise<void>;
+};

package/types/workflow.d.ts

@@ -0,0 +1,91 @@
+export type WorkflowStepHandler<TData = any> = (ctx: {
+  data: TData;
+  prevOutput: any;
+  input?: any;
+  rest: any;
+  error: any;
+  jwt: any;
+}) => Promise<any>;
+
+export type WorkflowCompensationHandler<TData = any> = (ctx: {
+  data: TData;
+  /** The output of the failed step (if any) */
+  stepOutput: any;
+  /** The error that caused the failure */
+  stepError: { message: string; code?: string };
+  rest: any;
+  error: any;
+  jwt: any;
+}) => Promise<void>;
+
+export type WorkflowStep<TData = any> = {
+  id: string;
+  name?: string;
+  description?: string;
+  exec: WorkflowStepHandler<TData>;
+  /** Compensation handler called when this step fails (executed in reverse order) */
+  compensate?: WorkflowCompensationHandler<TData>;
+  /** List of step IDs this compensation depends on / targets */
+  depend?: string[];
+  condition?: (ctx: {
+    data: TData;
+    prevOutput: any;
+  }) => boolean | Promise<boolean>;
+  input?: any;
+  output?: any;
+};
+
+export type WorkflowContextField = {
+  type: 'string' | 'number' | 'date';
+  index?: boolean | 1 | -1;
+};
+
+export type WorkflowContextFields = Record<string, WorkflowContextField>;
+
+export type WorkflowDefinition<TData = any> = {
+  id: string;
+  name: string;
+  description?: string;
+  version?: number;
+  context?: WorkflowContextFields;
+  exec?: WorkflowStepHandler<TData>;
+  steps: WorkflowStep<TData>[];
+  /** Global compensation handlers executed when any step fails (reverse order) */
+  compensations?: WorkflowStep<TData>[];
+  _tenant_?: string;
+  _isWorkflow_?: boolean;
+};
+
+export type WorkflowRunStatus = 'pending' | 'running' | 'completed' | 'failed' | 'paused' | 'cancelled' | 'skipped';
+
+export type WorkflowRunStep = {
+  stepId: string;
+  name?: string;
+  status: WorkflowRunStatus;
+  input?: any;
+  output?: any;
+  error?: { message: string; code?: string };
+  startedAt: Date;
+  completedAt?: Date;
+};
+
+export type WorkflowRun = {
+  _id: string;
+  workflowId: string;
+  workflowVersion?: number;
+  tenant_id: string;
+  status: WorkflowRunStatus;
+  progress: number;
+  data: any;
+  context?: any;
+  currentStep: number;
+  totalExecuted: number;
+  totalSkipped: number;
+  steps: WorkflowRunStep[];
+  /** Compensation steps that were executed */
+  compensations?: WorkflowRunStep[];
+  error?: { message: string; code?: string; stepId?: string };
+  createdAt: Date;
+  updatedAt: Date;
+  completedAt?: Date;
+};

package/utils/cache.ts

@@ -0,0 +1,96 @@
+import { BentoCache, bentostore } from "bentocache";
+import { memoryDriver } from "bentocache/drivers/memory";
+import { redisDriver } from "bentocache/drivers/redis";
+import { fileDriver } from "bentocache/drivers/file";
+import path from "path";
+const drivers = {
+    memoryDriver,
+    redisDriver,
+    fileDriver,
+}
+
+type Driver = 'memory' | 'redis' | 'filesystem';
+
+type CacheOptions = {
+    filesystem?: {
+        directory: string;
+    },
+    redis?: {
+        connection: {
+            host: string;
+            port: number;
+            password: string;
+        };
+    },
+    pruneInterval?: string;
+}
+
+class Cache {
+    #cache: InstanceType<typeof BentoCache>;
+    constructor(driver: Driver, options?: CacheOptions) {
+        let store = bentostore().useL1Layer(memoryDriver({
+        }))
+
+        if (driver == 'filesystem') {
+            store = store.useL2Layer(fileDriver({
+                directory: path.join(process.cwd(), '.cache'),
+                pruneInterval: '1h'
+            }))
+        }
+
+        if (driver == 'redis' && options?.redis?.connection) {
+            store = store.useL2Layer(redisDriver({
+                connection: options.redis.connection
+            }))
+        }
+        this.#cache = new BentoCache({
+            default: driver,
+            stores: {
+                [driver]: store,
+            }
+        })
+    }
+}
+
+
+function useRedisCache(options: {
+    connection: {
+        host: string;
+        port: number;
+        password: string;
+    };
+    pruneInterval?: string;
+}) {
+    return new Cache('redis', {
+        redis: {
+            connection: options.connection,
+        },
+        pruneInterval: options.pruneInterval,
+    });
+}
+
+function useMemoryCache() {
+    return new Cache('memory');
+}
+
+function useFilesystemCache(options: {
+    directory: string;
+    pruneInterval?: string;
+}) {
+    return new Cache('filesystem', {
+        filesystem: {
+            directory: options.directory,
+        },
+        pruneInterval: options.pruneInterval,
+    });
+}
+
+
+
+export default Cache;
+export {
+    Cache,
+    useFilesystemCache,
+    useMemoryCache,
+    useRedisCache
+}