@anteros/core 0.0.1-alpha.1

package/tests/api.test.ts

@@ -0,0 +1,281 @@
+import { describe, it, expect, beforeAll, afterAll } from "bun:test";
+import { useRest } from "../database/rest";
+import { formatConfig, cfg } from "../server/config";
+import { syncTenants } from "../database/tenant";
+import { syncCollections } from "../database/collection";
+
+const TEST_TENANT = "test";
+const TEST_DB = "mongodb://localhost:27017/_DB_TEST";
+
+let rest: InstanceType<typeof useRest>;
+
+beforeAll(async () => {
+    formatConfig({
+        tenants: [{ id: TEST_TENANT, dir: "src", database: { uri: TEST_DB } }],
+    });
+    await syncTenants();
+    await syncCollections();
+
+    (cfg as any).collections = [
+        {
+            _tenant_: TEST_TENANT,
+            slug: "items",
+            fields: [
+                { name: "title", type: "string", required: true },
+                { name: "count", type: "number" },
+            ],
+            api: { access: { "*": true } },
+        },
+    ];
+
+    rest = new useRest({ internal: false, tenant_id: TEST_TENANT });
+});
+
+afterAll(async () => {
+    try { await rest.db.collection("items").drop(); } catch (_) {}
+    try { await rest.db.collection("_locks_").drop(); } catch (_) {}
+});
+
+// ─── CRUD ────────────────────────────────────────────────────────────
+
+describe("insertOne", () => {
+    it("returns _id as 24-char hex string", async () => {
+        const doc = await rest.insertOne("items", { title: "hello", count: 1 });
+        expect(doc._id).toBeString();
+        expect(doc._id.length).toBe(24);
+    });
+    it("sets createdAt and updatedAt", async () => {
+        const doc = await rest.insertOne("items", { title: "ts" });
+        expect(doc.createdAt).toBeString();
+        expect(doc.updatedAt).toBeString();
+    });
+});
+
+describe("find", () => {
+    it("returns an array", async () => {
+        expect(Array.isArray(await rest.find("items", {}))).toBe(true);
+    });
+    it("filters with $match", async () => {
+        await rest.insertOne("items", { title: "match-me", count: 42 });
+        const docs = await rest.find("items", { $match: { count: 42 } });
+        expect(docs.length).toBeGreaterThanOrEqual(1);
+    });
+    it("matches _id string", async () => {
+        const doc = await rest.insertOne("items", { title: "by-id" });
+        const docs = await rest.find("items", { $match: { _id: doc._id } });
+        expect(docs.length).toBe(1);
+    });
+    it("respects $limit", async () => {
+        await rest.insertOne("items", { title: "a1" });
+        await rest.insertOne("items", { title: "a2" });
+        expect((await rest.find("items", { $limit: 1 })).length).toBe(1);
+    });
+});
+
+describe("findOne", () => {
+    it("returns single doc by _id", async () => {
+        const doc = await rest.insertOne("items", { title: "single" });
+        expect((await rest.findOne("items", doc._id)).title).toBe("single");
+    });
+    it("returns null for unknown id", async () => {
+        expect(await rest.findOne("items", "aaaaaaaaaaaaaaaaaaaaaaaa")).toBeNull();
+    });
+});
+
+describe("updateOne", () => {
+    it("$set title and changes updatedAt", async () => {
+        const doc = await rest.insertOne("items", { title: "old" });
+        const upd = await rest.updateOne("items", doc._id, { $set: { title: "new" } });
+        expect(upd.title).toBe("new");
+        expect(upd.updatedAt).not.toBe(doc.updatedAt);
+    });
+});
+
+describe("deleteOne", () => {
+    it("deletes and returns _id", async () => {
+        const doc = await rest.insertOne("items", { title: "del-me" });
+        expect((await rest.deleteOne("items", doc._id))._id).toBe(doc._id);
+    });
+});
+
+describe("insertMany", () => {
+    it("inserts and returns array with _id", async () => {
+        const docs = await rest.insertMany("items", [{ title: "m1" }, { title: "m2" }]);
+        expect(docs.length).toBe(2);
+        expect(docs[0]._id).toBeString();
+        expect(docs[1]._id).toBeString();
+    });
+});
+
+describe("updateMany", () => {
+    it("updates multiple by ids", async () => {
+        const a = await rest.insertOne("items", { title: "u1", count: 1 });
+        const b = await rest.insertOne("items", { title: "u2", count: 1 });
+        const r = await rest.updateMany("items", [a._id, b._id], { $set: { count: 99 } });
+        expect(r).toBeDefined();
+    });
+});
+
+describe("findOneAndUpdate", () => {
+    it("finds and updates atomically", async () => {
+        await rest.insertOne("items", { title: "fau", count: 0 });
+        const doc = await rest.findOneAndUpdate("items", { title: "fau" }, { $set: { count: 10 } });
+        expect(doc.count).toBe(10);
+    });
+});
+
+describe("deleteMany", () => {
+    it("deletes multiple by ids", async () => {
+        const a = await rest.insertOne("items", { title: "d1" });
+        const b = await rest.insertOne("items", { title: "d2" });
+        const r = await rest.deleteMany("items", [a._id, b._id]);
+        expect(r).toBeDefined();
+    });
+});
+
+describe("aggregate", () => {
+    it("returns array from pipeline", async () => {
+        await rest.insertOne("items", { title: "agg", count: 5 });
+        const docs = await rest.aggregate("items", [{ $match: { title: "agg" } }, { $limit: 1 }]);
+        expect(docs.length).toBe(1);
+    });
+    it("rejects $where", async () => {
+        await expect(rest.aggregate("items", [{ $where: "1" }])).rejects.toThrow();
+    });
+});
+
+// ─── UTILS ───────────────────────────────────────────────────────────
+
+describe("countDocuments", () => {
+    it("returns a number", async () => {
+        const n = await rest.countDocuments("items", {});
+        expect(typeof n).toBe("number");
+    });
+    it("counts with filter", async () => {
+        await rest.insertOne("items", { title: "count-me" });
+        const n = await rest.countDocuments("items", { title: "count-me" });
+        expect(n).toBeGreaterThanOrEqual(1);
+    });
+});
+
+describe("bulkWrite", () => {
+    it("executes mixed operations", async () => {
+        const result = await rest.bulkWrite("items", [
+            { insertOne: { document: { title: "bw1" } } },
+            { insertOne: { document: { title: "bw2" } } },
+        ]);
+        expect(result.insertedCount).toBe(2);
+    });
+});
+
+describe("bulkUpdate", () => {
+    it("updates many documents matching filters", async () => {
+        await rest.insertOne("items", { title: "bu1", count: 1 });
+        await rest.insertOne("items", { title: "bu2", count: 1 });
+        const r = await rest.bulkUpdate("items", [
+            { updateMany: { filter: { count: 1 }, update: { $set: { count: 100 } } } },
+        ]);
+        expect(r.modifiedCount).toBeGreaterThanOrEqual(1);
+    });
+});
+
+describe("stats", () => {
+    it("returns collection stats", async () => {
+        const s = await rest.stats("items");
+        expect(s).toBeDefined();
+        expect(typeof s).toBe("object");
+    });
+});
+
+describe("audit", () => {
+    it("adds and retrieves activities", async () => {
+        await rest.audit.addActivities([{
+            internal: false,
+            trace: { id: crypto.randomUUID() },
+            request: null,
+            meta: {},
+            operation: {
+                tenant: TEST_TENANT,
+                action: "test",
+                collection: "items",
+                status: "success",
+                input: null,
+                result: null,
+                error: null,
+                duration: 0,
+                transaction: false,
+            },
+            ts: new Date(),
+        }]);
+        const activities = await rest.audit.getActivities({ $limit: 10 });
+        expect(Array.isArray(activities)).toBe(true);
+        expect(activities.length).toBeGreaterThanOrEqual(1);
+    });
+});
+
+describe("workflows", () => {
+    it("returns workflows array", async () => {
+        const w = await rest.workflows({});
+        expect(Array.isArray(w)).toBe(true);
+    });
+});
+
+describe("lock / unlock", () => {
+    it("acquires a lock (throws if held)", async () => {
+        await rest.unlock("test-lock").catch(() => {});
+        await expect(rest.lock("test-lock", 5000)).resolves.toBeUndefined();
+    });
+
+    it("fails to acquire same lock twice", async () => {
+        await rest.unlock("test-lock-2").catch(() => {});
+        await rest.lock("test-lock-2", 10000);
+        await expect(rest.lock("test-lock-2", 1000)).rejects.toThrow();
+        await rest.unlock("test-lock-2");
+    });
+});
+
+describe("transactions", () => {
+    it("commits a transaction (requires replica set)", async () => {
+        try {
+            rest.startSession();
+            rest.startTransaction();
+            await rest.insertOne("items", { title: "tx-commit" });
+            await rest.commitTransaction();
+            await rest.endSession();
+            const docs = await rest.find("items", { $match: { title: "tx-commit" } });
+            expect(docs.length).toBe(1);
+        } catch (err: any) {
+            if (err?.message?.includes("retryable writes") || err?.message?.includes("replica set")) {
+                console.warn("Skipping transaction test: MongoDB standalone");
+                return;
+            }
+            throw err;
+        }
+    });
+
+    it("aborts a transaction (requires replica set)", async () => {
+        try {
+            rest.startSession();
+            rest.startTransaction();
+            await rest.insertOne("items", { title: "tx-abort" });
+            await rest.abortTransaction();
+            await rest.endSession();
+            const docs = await rest.find("items", { $match: { title: "tx-abort" } });
+            expect(docs.length).toBe(0);
+        } catch (err: any) {
+            if (err?.message?.includes("retryable writes") || err?.message?.includes("replica set")) {
+                console.warn("Skipping transaction test: MongoDB standalone");
+                return;
+            }
+            throw err;
+        }
+    });
+});
+
+describe("watch", () => {
+    it("returns a change stream", async () => {
+        const stream = await rest.watch("items", [{ $match: { operationType: "insert" } }]);
+        expect(stream).toBeDefined();
+        await stream.close();
+    });
+});

package/tsconfig.json

@@ -0,0 +1,36 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": [
+      "ESNext"
+    ],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false,
+    "experimentalDecorators": true,
+  },
+  "include": [
+    "types/**/*.d.ts",
+    "**/*.ts"
+  ],
+  "exclude": [
+    "dist"
+  ]
+}

package/types/activity.d.ts

@@ -0,0 +1,45 @@
+export type ActivityInput = {
+    internal: boolean;
+    trace: {
+        id: string;
+        comment?: string;
+        tag?: string;
+        version?: string;
+    };
+    request?: {
+        ip?: string;
+        user_agent?: string;
+        headers?: Record<string, string>;
+        method?: string;
+        path?: string;
+        query?: Record<string, any>;
+    };
+    meta: {
+        environment?: string;
+        hostname?: string;
+        core_version?: string;
+        platform?: string;
+    };
+    operation: {
+        tenant: string;
+        action: string;
+        collection: string;
+        collectionType?: "document" | "file";
+        status: "success" | "error";
+        input: any;
+        result: any;
+        error: {
+            message: string;
+            code: string;
+        } | null;
+        duration: number;
+        transaction: boolean;
+        token?: {
+            decoded: Record<string, unknown> | null;
+            value: string | null;
+            provided: boolean;
+            expired: boolean;
+        };
+    };
+    ts: Date;
+}

package/types/api.d.ts

@@ -0,0 +1,85 @@
+export declare enum ApiActions {
+    insertOne = "insertOne",
+    insertMany = "insertMany",
+    updateOne = "updateOne",
+    updateMany = "updateMany",
+    deleteOne = "deleteOne",
+    deleteMany = "deleteMany",
+    findOne = "findOne",
+    find = "find",
+    runAction = "runAction",
+    runService = "runService",
+    upload = "upload",
+    auth = "auth",
+    login = "login",
+    aggregate = "aggregate",
+
+}
+
+export type ActionsApiList =
+    | "findOneAndUpdate"
+    | "insertOne"
+    | "insertMany"
+    | "updateOne"
+    | "updateMany"
+    | "deleteOne"
+    | "deleteMany"
+    | "findOne"
+    | "find"
+    | "runAction"
+    | "runService"
+    | "upload"
+    | "auth"
+    | "login"
+    | "logout"
+    | "aggregate"
+    | "*"
+
+
+export type ApiOptions = {
+    cleanDeep?: boolean;
+    useCache?: boolean;
+};
+
+export type ApiParams = {
+    action: ApiActions;
+    collection: string;
+    tenant: string;
+};
+
+
+export type ApiAccess = {
+    [key in ActionsApiList | (string & {})]?:
+    | boolean
+    | ((ctx: {
+        rest: InstanceType<typeof useRest>;
+        error: typeof fn.error;
+        jwt: typeof jwt;
+        /** `value`: raw JWT string; `decoded`: verified claims (or null if unauthenticated). */
+        token: { value: string | null; decoded: Record<string, unknown> | null; provided: boolean; expired: boolean };
+    }) => boolean);
+};
+export type ApiActions = {
+    [key: string]:
+    | boolean
+    | ((ctx: {
+        rest: InstanceType<typeof useRest>;
+        error: typeof fn.error;
+        jwt: typeof jwt;
+    }) => boolean);
+};
+
+export type ApiResponse = {
+    data: any;
+    error: any;
+};
+
+
+export type updateApiOptions = {
+    cleanDeep?: boolean;
+    upsert?: boolean;
+}
+
+export type findApiOptions = {
+    cleanDeep?: boolean;
+}

package/types/collection.d.ts

@@ -0,0 +1,82 @@
+import type { AppError, fn } from "../lib/error";
+import type { Field } from "./field";
+import type { HooksCollection } from "./hook";
+import type Joi from "joi";
+import type { Cookies } from "hono/types";
+import type { Context } from "hono";
+import type { useRest } from "../database/rest";
+import type { jwt } from "../utils/func";
+import type { ActionsApiList, ApiAccess, ApiActions } from "./api";
+export type Collection = {
+    type?: "document" | "file";
+    slug: string;
+    studio?: {
+        label?: string;
+        info?: string;
+    };
+    hooks?: {
+        beforeOperation?: HooksCollection['beforeOperation'];
+        afterOperation?: HooksCollection['afterOperation'];
+    },
+    fields: Field[];
+    api?: {
+        access?: ApiAccess,
+        auth?: {
+            enabled: boolean;
+            onLogin: (ctx: {
+                rest: InstanceType<typeof useRest>;
+                payload: any;
+                error: typeof fn.error;
+                jwt: typeof jwt;
+                req: {
+                    cookies: {
+                        set: (name: string, value: string, options?: {
+                            httpOnly?: boolean;
+                            secure?: boolean;
+                            maxAge?: number;
+                            path?: string;
+                            domain?: string;
+                            sameSite?: 'lax' | 'strict' | 'none';
+                        }) => any;
+                        get: (name: string) => string | undefined;
+                        delete: (name: string) => void;
+                    }
+
+                }
+            }) => Promise<{
+                token: string;
+                data?: any;
+            } | typeof fn.error>;
+            onLogout?: (ctx: {
+                rest: InstanceType<typeof useRest>;
+                payload: any;
+                error: typeof fn.error;
+                jwt: typeof jwt;
+                req: {
+                    cookies: {
+                        delete: (name: string) => void;
+                    }
+                }
+            }) => Promise<void>;
+        };
+        privateFields?: (string | RegExp)[];
+        readOnlyFields?: (string | RegExp)[];
+    };
+    actions?: {
+        [key: string]: (ctx: {
+            rest: InstanceType<typeof useRest>;
+            data: any;
+            error: typeof fn.error;
+        }) => Promise<any>;
+    };
+    /**
+     * The tenant id of the collection
+     * @type {string}
+     */
+    _tenant_?: string;
+    _isTimeSerie_?: boolean;
+    _isCollection_?: boolean;
+    _schema_?: Joi.Schema;
+    _schemaPartial_?: Joi.Schema;
+
+}

package/types/config.d.ts

@@ -0,0 +1,55 @@
+import type { Context } from "hono";
+import type { Tenant } from "./tenant";
+import type { IPRestrictionRule } from "hono/ip-restriction";
+import type { Collection } from "./collection";
+import type { Route } from "./route";
+import type { Service } from "./service";
+import type { Script } from "./scripts";
+import type { FileCollection } from "./file";
+export type ServerConfig = {
+    version?: string;
+    clusterMode?: boolean;
+    server: {
+        name?: string;
+        port: number;
+        body?: {
+            maxSize?: number;
+        };
+        cors?: {
+            origin: string | string[] | ((ctx: { origin: string, c: Context }) => string | string[]);
+            credentials?: boolean;
+            allowHeaders?: string[];
+            allowMethods?: string[];
+        }
+        ipRestriction?: {
+            denyList?: IPRestrictionRule[];
+            allowList?: IPRestrictionRule[];
+        }
+        jwt?: {
+            secret?: string;
+            expiresIn?: string;
+        }
+        rateLimit?: {
+            enabled?: boolean;
+            windowMs?: number;
+            max?: number;
+            /** If true, uses Redis store (requires ioredis client available) */
+            useRedis?: boolean;
+            /** Stricter limits for login endpoints */
+            login?: {
+                windowMs?: number;
+                max?: number;
+            };
+        };
+    }
+    tenants: Tenant[];
+}
+
+export type Config = ServerConfig & {
+    version?: string;
+    collections?: Collection[]
+    routes?: Route[]
+    services?: Service[]
+    scripts?: Script[]
+    fileCollections?: FileCollection[]
+}

package/types/field.d.ts

@@ -0,0 +1,72 @@
+import type { Type } from "arktype";
+import type { GenerateRandomOptions } from "../utils/func";
+import type Joi from "joi";
+export type FieldType = "boolean"
+    | "ipv4"
+    | "ipv6"
+    | "url"
+    | "date"
+    | "datetime-local"
+    | "email"
+    | "array"
+    | "number"
+    | "integer"
+    | "password"
+    | "random"
+    | "relationship"
+    | "string"
+    | "enum"
+    | "json"
+    | "geojson.Point"
+    | "geojson.LineString"
+    | "geojson.Polygon"
+    | "uuid"
+
+
+
+
+export type enumOptions = {
+    multiple?: boolean;
+    items?: Array<string | number | boolean | object>;
+}
+
+
+export type Field = {
+    name: string;
+    description?: string;
+    type: FieldType;
+    studio?: {
+        label?: string;
+        info?: string;
+        display?: string;
+    };
+    validate?: {
+        schema: Joi.Schema
+    },
+    required?: boolean;
+    enumOptions?: enumOptions;
+    unique?: boolean;
+    nullable?: boolean;
+    empty?: boolean;
+    defaultValue?: number | string | boolean | object | array<any>;
+    index?: boolean;
+    indexType?: "text"
+    | "hashed"
+    | "2dsphere"
+    | "2d"
+    indexOptions?: {
+        expireAfterSeconds?: number;
+        sparse?: boolean;
+        version?: number;
+        unique?: boolean;
+    };
+    relation?: {
+        to: string;
+        hasMany?: boolean;
+        pipeline?: Array<any>;
+    };
+    /**
+     * Required if type === "random"
+     */
+    randomOptions?: GenerateRandomOptions;
+}