@anteros/core 0.0.1-alpha.1

package/database/rest.ts

@@ -0,0 +1,14 @@
+import type { RestOptions } from "../types/rest";
+import { MongoRest } from "./mongodbadapter";
+
+class Rest extends MongoRest {
+    constructor(options: RestOptions) {
+        super(options);
+    }
+}
+
+const useRest = Rest
+
+export {
+    useRest,
+}

package/database/schema.ts

@@ -0,0 +1,160 @@
+
+import type { Collection as CollectionType } from "../types/collection";
+import Joi, { type AnySchema } from "joi";
+
+
+let s = Joi.object({
+    name: Joi.string().required(),
+})
+
+
+
+
+function buildSchema(col: CollectionType, opts = {
+    partial: false
+}) {
+
+    let propertiesSchema = {
+        createdAt: Joi.date(),
+        updatedAt: Joi.date(),
+    } as {
+        [key: string]: AnySchema
+    }
+    for (const f of col.fields) {
+
+        if (f.type && f.name) {
+
+            let fieldName = f.name
+
+            if (f.type == 'string') {
+                propertiesSchema[fieldName] = Joi.string()
+            }
+
+            if (f.type == 'password') {
+                propertiesSchema[fieldName] = Joi.string()
+            }
+
+            if (f.type == 'number') {
+                propertiesSchema[fieldName] = Joi.number()
+            }
+
+            if (f.type == 'integer') {
+                propertiesSchema[fieldName] = Joi.number().integer()
+            }
+
+            if (f.type == 'boolean') {
+                propertiesSchema[fieldName] = Joi.boolean()
+            }
+
+            if (f.type.match(/(date|datetime-local)/)) {
+                propertiesSchema[fieldName] = Joi.date()
+            }
+
+            if (f.type == 'array') {
+                propertiesSchema[fieldName] = Joi.array()
+            }
+
+            if (f.type == 'json') {
+                propertiesSchema[fieldName] = Joi.object()
+            }
+
+            if (f.type == 'uuid') {
+                propertiesSchema[fieldName] = Joi.string().uuid()
+            }
+            if (f.type == 'email') {
+                propertiesSchema[fieldName] = Joi.string().email()
+            }
+
+            if (f.type == 'url') {
+                propertiesSchema[fieldName] = Joi.string().uri()
+            }
+
+            if (f.type == 'ipv4') {
+                propertiesSchema[fieldName] = Joi.string().ip({ version: 'ipv4' })
+            }
+
+            if (f.type == 'ipv6') {
+                propertiesSchema[fieldName] = Joi.string().ip({ version: 'ipv6' })
+            }
+
+            if (f.type == 'enum' && !f.enumOptions?.multiple) {
+                propertiesSchema[fieldName] = Joi.string().valid(...f.enumOptions?.items || [])
+            }
+
+            if (f.type == 'enum' && f.enumOptions?.multiple) {
+                propertiesSchema[fieldName] = Joi.array().items(Joi.string().valid(...f.enumOptions?.items || []))
+            }
+
+            if (f.type == 'random') {
+                propertiesSchema[fieldName] = Joi.string()
+            }
+
+            if (f.type == 'random' && f?.randomOptions?.toNumber) {
+                propertiesSchema[fieldName] = Joi.number()
+            }
+
+            if (f?.type.match(/(geojson\.Point|geojson\.LineString|geojson\.Polygon)/)) {
+                propertiesSchema[fieldName] = Joi.object({
+                    type: Joi.string().valid("Point", "LineString", "Polygon", "MultiPoint").required(),
+                    coordinates: Joi.alternatives().conditional("type", [
+                        {
+                            is: "Point",
+                            then: Joi.array().items(Joi.number()).length(2).required(), // [lng, lat]
+                        },
+                        {
+                            is: Joi.string().valid("LineString", "MultiPoint"),
+                            then: Joi.array().items(Joi.array().items(Joi.number()).length(2)).required(), // [[lng, lat], ...]
+                        },
+                        {
+                            is: "Polygon",
+                            then: Joi.array().items(Joi.array().items(Joi.array().items(Joi.number()).length(2))).required(), // [[[lng, lat], ...]]
+                        },
+                    ]),
+                });
+            }
+
+            if (f?.type == 'relationship') {
+                propertiesSchema[fieldName] = Joi.string().optional().messages({
+                    'string.base': `${f.name} must be  a string (ObjectId)`,
+                })
+            }
+
+            if (f?.type == 'relationship' && f?.relation?.hasMany) {
+                propertiesSchema[fieldName] = Joi.array().items(Joi.string().optional()).messages({
+                    'string.base': `${f.name} must be  a string (ObjectId)`,
+                })
+            }
+
+            if (f.validate?.schema) {
+                propertiesSchema[fieldName] = f.validate.schema
+            }
+
+            if (f?.required) {
+                propertiesSchema[fieldName] = propertiesSchema[fieldName]?.required()!
+            } else {
+                propertiesSchema[fieldName] = propertiesSchema[fieldName]?.optional()!
+            }
+
+            if (f?.nullable) {
+                propertiesSchema[fieldName] = propertiesSchema[fieldName]?.allow(null)
+            }
+
+            if (f?.empty) {
+                propertiesSchema[fieldName] = propertiesSchema[fieldName]?.allow('')
+            }
+
+        }
+    }
+
+    let schema = Joi.object(propertiesSchema).min(1)
+    return opts.partial ? buildSchemaForkOptional(schema) : schema
+}
+
+function buildSchemaForkOptional(schemaPassed: AnySchema): AnySchema {
+    return schemaPassed.fork(
+        Object.keys(schemaPassed.describe().keys),
+        (field) => field.optional()
+    )
+}
+
+export { buildSchema, buildSchemaForkOptional }

package/database/tenant.ts

@@ -0,0 +1,37 @@
+import type { Tenant } from "../types/tenant";
+import { cfg } from "../server/config";
+import { useRest } from "./rest";
+async function syncTenants() {
+    try {
+        for await (let tenant of cfg.tenants ?? []) {
+            let rest = new useRest({
+                database: {
+                    uri: tenant.database.uri,
+                    options: {
+                        timeoutMS: 2000,
+                        ...tenant.database.options,
+                    },
+                }
+            })
+            const { client, db } = await rest.connect()
+            tenant.database.client = client
+            tenant.database.db = db
+        }
+    } catch (err: any) {
+        console.error('Error bootstrapping tenants', err?.message)
+        process.exit(1)
+    }
+}
+
+function getTenant(tenantId: string): Tenant | null {
+    let findTenant = cfg.tenants?.find(tenant => tenant.id == tenantId)
+    if (findTenant) {
+        return findTenant
+    }
+    return null
+}
+
+export {
+    syncTenants,
+    getTenant
+}

package/database/workflow.ts

@@ -0,0 +1,384 @@
+import { cfg } from "../server/config";
+import { getTenant } from "./tenant";
+import { AppError, fn } from "../lib/error";
+import * as func from "../utils/func";
+import { useRest } from "./rest";
+import { getWorkflow } from "../lib/workflow";
+import crypto from "crypto";
+import type { WorkflowDefinition, WorkflowRun, WorkflowRunStep, WorkflowRunStatus } from "../types/workflow";
+
+class Workflow {
+  #tenant_id: string;
+
+  constructor(tenant_id: string) {
+    this.#tenant_id = tenant_id;
+  }
+
+  private async getCollection() {
+    const tenant = getTenant(this.#tenant_id);
+    const db = tenant?.database?.db;
+    if (!db) throw new AppError('Database not found', { code: 'DB_NOT_FOUND', status: 500 });
+    return db.collection('_workflows_');
+  }
+
+  /**
+   * Run a workflow by its ID with the given data.
+   * Executes each step sequentially and tracks progress.
+   */
+  async run(workflowId: string, data: any, context?: any): Promise<WorkflowRun> {
+    const wf = getWorkflow(workflowId, this.#tenant_id);
+    if (!wf) throw new AppError(`Workflow '${workflowId}' not found`, { code: 'WORKFLOW_NOT_FOUND', status: 404 });
+
+    const runId = crypto.randomUUID();
+    const now = new Date();
+
+    const run: WorkflowRun = {
+      _id: runId,
+      workflowId,
+      workflowVersion: wf.version,
+      tenant_id: this.#tenant_id,
+      status: 'running',
+      progress: 0,
+      data,
+      context,
+      currentStep: 0,
+      totalExecuted: 0,
+      totalSkipped: 0,
+      steps: wf.steps.map(s => ({
+        stepId: s.id,
+        name: s.name,
+        status: 'pending' as WorkflowRunStatus,
+        startedAt: now,
+      })),
+      compensations: [],
+      createdAt: now,
+      updatedAt: now,
+    };
+
+    await this.saveRun(run);
+
+    // Execute global exec if present
+    try {
+      if (wf.exec) {
+        await wf.exec({ data, prevOutput: null, rest: this, error: fn.error, jwt: func.jwt, input: undefined });
+      }
+    } catch (err: any) {
+      run.status = 'failed';
+      run.error = { message: err.message || 'Workflow execution failed', stepId: '__global__' };
+      run.updatedAt = new Date();
+      await this.saveRun(run);
+      throw err;
+    }
+
+    // Execute steps sequentially
+    for (let i = 0; i < wf.steps.length; i++) {
+      const stepDef = wf.steps[i]!;
+      run.currentStep = i;
+      const stepRun: WorkflowRunStep = {
+        stepId: stepDef.id,
+        name: stepDef.name,
+        status: 'running',
+        input: data,
+        startedAt: new Date(),
+      };
+
+      run.steps[i] = stepRun;
+      run.updatedAt = new Date();
+      await this.saveRun(run);
+
+      try {
+        const prevOutput = i > 0 ? run.steps[i - 1]?.output ?? null : null;
+
+        // Vérifier la condition du step
+        if (stepDef.condition) {
+          const shouldRun = await stepDef.condition({ data, prevOutput });
+          if (!shouldRun) {
+            stepRun.status = 'skipped';
+            stepRun.completedAt = new Date();
+            run.steps[i] = stepRun;
+            run.totalSkipped = run.steps.filter(s => s.status === 'skipped').length;
+            run.progress = Math.round(((i + 1) / wf.steps.length) * 100);
+            run.updatedAt = new Date();
+            await this.saveRun(run);
+            continue; // saute ce step
+          }
+        }
+
+        const result = await stepDef.exec({ data, prevOutput, input: stepDef.input, rest: this, error: fn.error, jwt: func.jwt });
+        stepRun.status = 'completed';
+        stepRun.output = result;
+        stepRun.completedAt = new Date();
+        run.steps[i] = stepRun;
+        run.totalExecuted = run.steps.filter(s => s.status === 'completed').length;
+        run.progress = Math.round(((i + 1) / wf.steps.length) * 100);
+      } catch (err: any) {
+        stepRun.status = 'failed';
+        stepRun.error = { message: err.message || 'Step failed', code: err.code };
+        stepRun.completedAt = new Date();
+        run.steps[i] = stepRun;
+        run.totalExecuted = run.steps.filter(s => s.status === 'completed').length;
+        run.status = 'failed';
+        run.error = { message: err.message || 'Workflow failed', code: err.code, stepId: stepDef.id };
+        run.updatedAt = new Date();
+        await this.saveRun(run);
+
+        // Exécuter les compensations (steps réussis en ordre inverse)
+        if (wf.compensations?.length) {
+          const failedIndex = run.steps.findIndex(s => s.status === 'failed');
+          const stepsToCompensate = run.steps.slice(0, failedIndex).filter(s => s.status === 'completed').reverse();
+          run.compensations = [];
+          for (const completedStep of stepsToCompensate) {
+            const compDef = wf.compensations?.find(c => c.depend?.includes(completedStep.stepId) || c.id === completedStep.stepId);
+            if (!compDef?.exec) continue;
+            try {
+              await compDef.exec({
+                data: run.data,
+                prevOutput: completedStep.output,
+                input: undefined,
+                rest: this,
+                error: fn.error,
+                jwt: func.jwt,
+              });
+              run.compensations.push({
+                stepId: compDef.id,
+                name: compDef.name,
+                status: 'completed',
+                output: null,
+                startedAt: new Date(),
+                completedAt: new Date(),
+              });
+            } catch (compErr: any) {
+              run.compensations.push({
+                stepId: compDef.id,
+                name: compDef.name,
+                status: 'failed',
+                error: { message: compErr.message || 'Compensation failed' },
+                startedAt: new Date(),
+                completedAt: new Date(),
+              });
+            }
+          }
+          run.updatedAt = new Date();
+          await this.saveRun(run);
+        }
+
+        throw err;
+      }
+    }
+
+    run.status = 'completed';
+    run.progress = 100;
+    run.completedAt = new Date();
+    run.updatedAt = new Date();
+    await this.saveRun(run);
+    return run;
+  }
+
+  /**
+   * Resume a paused or failed workflow run from the last failed/pending step.
+   */
+  async resume(runId: string, data?: any): Promise<WorkflowRun> {
+    const run = await this.getRun(runId);
+    if (!run) throw new AppError(`Workflow run '${runId}' not found`, { code: 'RUN_NOT_FOUND', status: 404 });
+    if (run.status === 'completed') throw new AppError('Workflow already completed', { code: 'RUN_COMPLETED', status: 400 });
+
+    const wf = getWorkflow(run.workflowId, this.#tenant_id);
+    if (!wf) throw new AppError(`Workflow '${run.workflowId}' not found`, { code: 'WORKFLOW_NOT_FOUND', status: 404 });
+
+    run.status = 'running';
+    run.data = data || run.data;
+    run.updatedAt = new Date();
+
+    // Find the first non-completed step
+    const startIndex = run.steps.findIndex(s => s.status !== 'completed');
+    if (startIndex === -1) {
+      run.status = 'completed';
+      run.progress = 100;
+      run.completedAt = new Date();
+      await this.saveRun(run);
+      return run;
+    }
+
+    for (let i = startIndex; i < wf.steps.length; i++) {
+      const stepDef = wf.steps[i]!;
+      run.currentStep = i;
+      const stepRun: WorkflowRunStep = {
+        stepId: stepDef.id,
+        name: stepDef.name,
+        status: 'running',
+        input: run.data,
+        startedAt: new Date(),
+      };
+      run.steps[i] = stepRun;
+      run.updatedAt = new Date();
+      await this.saveRun(run);
+
+      try {
+        const prevOutput = i > 0 ? run.steps[i - 1]?.output ?? null : null;
+
+        // Vérifier la condition du step
+        if (stepDef.condition) {
+          const shouldRun = await stepDef.condition({ data: run.data, prevOutput });
+          if (!shouldRun) {
+            stepRun.status = 'skipped';
+            stepRun.completedAt = new Date();
+            run.steps[i] = stepRun;
+            run.totalSkipped = run.steps.filter(s => s.status === 'skipped').length;
+            run.progress = Math.round(((i + 1) / wf.steps.length) * 100);
+            run.updatedAt = new Date();
+            await this.saveRun(run);
+            continue; // saute ce step
+          }
+        }
+
+        const result = await stepDef.exec({ data: run.data, prevOutput, input: stepDef.input, rest: this, error: fn.error, jwt: func.jwt });
+        stepRun.status = 'completed';
+        stepRun.output = result;
+        stepRun.completedAt = new Date();
+        run.steps[i] = stepRun;
+        run.totalExecuted = run.steps.filter(s => s.status === 'completed').length;
+        run.progress = Math.round(((i + 1) / wf.steps.length) * 100);
+      } catch (err: any) {
+        stepRun.status = 'failed';
+        stepRun.error = { message: err.message || 'Step failed', code: err.code };
+        stepRun.completedAt = new Date();
+        run.steps[i] = stepRun;
+        run.totalExecuted = run.steps.filter(s => s.status === 'completed').length;
+        run.status = 'failed';
+        run.error = { message: err.message || 'Workflow failed', code: err.code, stepId: stepDef.id };
+        run.updatedAt = new Date();
+        await this.saveRun(run);
+
+        // Exécuter les compensations (steps réussis en ordre inverse)
+        if (wf.compensations?.length) {
+          const failedIndex = run.steps.findIndex(s => s.status === 'failed');
+          const stepsToCompensate = run.steps.slice(0, failedIndex).filter(s => s.status === 'completed').reverse();
+          run.compensations = [];
+          for (const completedStep of stepsToCompensate) {
+            const compDef = wf.compensations?.find(c => c.depend?.includes(completedStep.stepId) || c.id === completedStep.stepId);
+            if (!compDef?.exec) continue;
+            try {
+              await compDef.exec({
+                data: run.data,
+                prevOutput: completedStep.output,
+                input: undefined,
+                rest: this,
+                error: fn.error,
+                jwt: func.jwt,
+              });
+              run.compensations.push({
+                stepId: compDef.id,
+                name: compDef.name,
+                status: 'completed',
+                output: null,
+                startedAt: new Date(),
+                completedAt: new Date(),
+              });
+            } catch (compErr: any) {
+              run.compensations.push({
+                stepId: compDef.id,
+                name: compDef.name,
+                status: 'failed',
+                error: { message: compErr.message || 'Compensation failed' },
+                startedAt: new Date(),
+                completedAt: new Date(),
+              });
+            }
+          }
+          run.updatedAt = new Date();
+          await this.saveRun(run);
+        }
+
+        throw err;
+      }
+    }
+
+    run.status = 'completed';
+    run.progress = 100;
+    run.completedAt = new Date();
+    run.updatedAt = new Date();
+    await this.saveRun(run);
+    return run;
+  }
+
+  /** Get a workflow run by ID */
+  async getRun(runId: string): Promise<WorkflowRun | null> {
+    const col = await this.getCollection();
+    const doc = await col.findOne({ _id: runId as any });
+    return doc as unknown as WorkflowRun | null;
+  }
+
+  /** List all runs for a workflow */
+  async listRuns(workflowId: string, limit = 20): Promise<WorkflowRun[]> {
+    const col = await this.getCollection();
+    const docs = await col.find({ workflowId }).sort({ createdAt: -1 }).limit(limit).toArray();
+    return docs as unknown as WorkflowRun[];
+  }
+
+  /** Get progress of a run (0-100) */
+  async getProgress(runId: string): Promise<{ progress: number; status: WorkflowRunStatus; currentStep: number; totalSteps: number; totalExecuted: number; totalSkipped: number } | null> {
+    const run = await this.getRun(runId);
+    if (!run) return null;
+    return {
+      progress: run.progress,
+      status: run.status,
+      currentStep: run.currentStep,
+      totalSteps: run.steps.length,
+      totalExecuted: run.totalExecuted,
+      totalSkipped: run.totalSkipped,
+    };
+  }
+
+  /** Pause a running workflow */
+  async pause(runId: string): Promise<void> {
+    const col = await this.getCollection();
+    await col.updateOne(
+      { _id: runId as any, status: 'running' },
+      { $set: { status: 'paused', updatedAt: new Date() } }
+    );
+  }
+
+  /** Cancel a workflow run permanently */
+  async cancel(runId: string): Promise<void> {
+    const col = await this.getCollection();
+    await col.updateOne(
+      { _id: runId as any },
+      { $set: { status: 'cancelled', updatedAt: new Date() } }
+    );
+  }
+
+  /** Resume all paused or failed workflows */
+  async resumeAll(data?: any): Promise<{ resumed: number; failed: number }> {
+    const col = await this.getCollection();
+    const runs = await col.find({
+      status: { $in: ['paused', 'failed'] }
+    }).toArray() as unknown as WorkflowRun[];
+
+    let resumed = 0;
+    let failed = 0;
+
+    for (const run of runs) {
+      try {
+        await this.resume(run._id, data);
+        resumed++;
+      } catch {
+        failed++;
+      }
+    }
+
+    return { resumed, failed };
+  }
+
+  private async saveRun(run: WorkflowRun): Promise<void> {
+    const col = await this.getCollection();
+    await col.replaceOne(
+      { _id: run._id as any },
+      run as any,
+      { upsert: true }
+    );
+  }
+}
+
+export function createWorkflow(tenant_id: string): Workflow {
+  return new Workflow(tenant_id);
+}

package/index.ts

@@ -0,0 +1,28 @@
+import { define } from "./lib/define";
+import { bootApp } from "./server/boot";
+import { useRest } from "./database/rest";
+import * as v from "joi";
+import utils from "./utils";
+import * as crypto from "./utils/crypto";
+
+
+// Imort bentocache use as cache
+import { useMemoryCache, useFilesystemCache, useRedisCache } from "./utils/cache";
+const cache = {
+    useMemoryCache,
+    useFilesystemCache,
+    useRedisCache
+}
+const app = {
+    boot: bootApp
+}
+
+export {
+    define,
+    app,
+    useRest,
+    v,
+    utils,
+    cache,
+    crypto,
+}

package/lib/asyncContextStorage.ts

@@ -0,0 +1,68 @@
+import { AsyncLocalStorage } from "async_hooks";
+
+const asyncContextStorage = new AsyncLocalStorage<Map<string, unknown>>();
+
+const REQUEST_STORAGE_PREFIX = ":::requestStorage:::";
+const SESSION_STORAGE_PREFIX = "::sessionStorage::";
+
+const requestCtxStorage = {
+    set(key: string, value: unknown): void {
+        asyncContextStorage.getStore()?.set(`${REQUEST_STORAGE_PREFIX}${key}`, value);
+    },
+    get<T = unknown>(key: string): T | undefined {
+        return asyncContextStorage.getStore()?.get(`${REQUEST_STORAGE_PREFIX}${key}`) as T | undefined;
+    },
+    delete(key: string): void {
+        asyncContextStorage.getStore()?.delete(`${REQUEST_STORAGE_PREFIX}${key}`);
+    },
+    clear(): void {
+        asyncContextStorage.getStore()?.clear();
+    }
+};
+
+interface SessionSetParams {
+    state: {
+        user: Record<string, unknown>;
+        [key: string]: unknown;
+    };
+    role: string;
+    token?: string;
+    expireIn?: number;
+}
+
+interface SessionData {
+    state: SessionSetParams["state"];
+    uuid: string;
+    role: string;
+    token?: string;
+    expireIn?: number;
+    isAuth: boolean;
+    _v: unknown;
+}
+
+const sessionCtxStorage = {
+    set(params: SessionSetParams): void {
+        const store = asyncContextStorage.getStore();
+        if (!store) return;
+        const data: SessionData = {
+            state: params.state,
+            uuid: crypto.randomUUID(),
+            role: params.role,
+            token: params.token,
+            expireIn: params.expireIn,
+            isAuth: !!params.state?.user && !!params.token,
+            _v: undefined,
+        };
+        store.set(SESSION_STORAGE_PREFIX, data);
+    },
+    get(): SessionData | undefined {
+        return asyncContextStorage.getStore()?.get(SESSION_STORAGE_PREFIX) as SessionData | undefined;
+    },
+    clear(): void {
+        asyncContextStorage.getStore()?.delete(SESSION_STORAGE_PREFIX);
+    }
+};
+
+
+export { asyncContextStorage, requestCtxStorage, sessionCtxStorage };
+