@anteros/core 0.0.40 → 0.0.42

package/database/schema.ts

@@ -1,5 +1,6 @@
 
 import type { Collection as CollectionType } from "../types/collection";
+import type { Field } from "../types/field";
 import Joi, { type AnySchema } from "joi";
 
 
@@ -10,6 +11,142 @@ let s = Joi.object({
 
 
 
+/**
+ * Build the Joi schema for a single field. Assumes `f.type` is set.
+ * Extracted so other features (e.g. `define.Vars`) can validate with the exact
+ * same rules as collections — without the `Joi.object(...).min(1)` wrapper.
+ */
+function fieldToSchema(f: Field): AnySchema | undefined {
+    let schema: AnySchema | undefined
+
+    if (f.type == 'string') {
+        schema = Joi.string()
+    }
+
+    if (f.type == 'password') {
+        schema = Joi.string()
+    }
+
+    if (f.type == 'number') {
+        schema = Joi.number()
+    }
+
+    if (f.type == 'integer') {
+        schema = Joi.number().integer()
+    }
+
+    if (f.type == 'boolean') {
+        schema = Joi.boolean()
+    }
+
+    if (f.type.match(/(date|datetime-local)/)) {
+        schema = Joi.date()
+    }
+
+    if (f.type == 'array') {
+        schema = Joi.array()
+    }
+
+    if (f.type == 'json') {
+        schema = Joi.object()
+    }
+
+    if (f.type == 'uuid') {
+        schema = Joi.string().uuid()
+    }
+    if (f.type == 'email') {
+        schema = Joi.string().email()
+    }
+
+    if (f.type == 'url') {
+        schema = Joi.string().uri()
+    }
+
+    if (f.type == 'slug') {
+        let slug = Joi.string().pattern(/^[a-z0-9]+(?:-[a-z0-9]+)*$/)
+        if (f.slugOptions?.min != null) slug = slug.min(f.slugOptions.min)
+        if (f.slugOptions?.max != null) slug = slug.max(f.slugOptions.max)
+        schema = slug
+    }
+
+    if (f.type == 'ipv4') {
+        schema = Joi.string().ip({ version: 'ipv4' })
+    }
+
+    if (f.type == 'ipv6') {
+        schema = Joi.string().ip({ version: 'ipv6' })
+    }
+
+    if (f.type == 'enum' && !f.enumOptions?.multiple) {
+        schema = Joi.string().valid(...f.enumOptions?.items || [])
+    }
+
+    if (f.type == 'enum' && f.enumOptions?.multiple) {
+        schema = Joi.array().items(Joi.string().valid(...f.enumOptions?.items || []))
+    }
+
+    if (f.type == 'random') {
+        schema = Joi.string()
+    }
+
+    if (f.type == 'random' && f?.randomOptions?.toNumber) {
+        schema = Joi.number()
+    }
+
+    if (f?.type.match(/(geojson\.Point|geojson\.LineString|geojson\.Polygon)/)) {
+        schema = 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') {
+        schema = Joi.string().optional().messages({
+            'string.base': `${f.name} must be  a string (ObjectId)`,
+        })
+    }
+
+    if (f?.type == 'relationship' && f?.relation?.hasMany) {
+        schema = Joi.array().items(Joi.string().optional()).messages({
+            'string.base': `${f.name} must be  a string (ObjectId)`,
+        })
+    }
+
+    if (f.validate?.schema) {
+        schema = f.validate.schema
+    }
+
+    if (f?.required) {
+        schema = schema?.required()
+    } else {
+        schema = schema?.optional()
+    }
+
+    if (f?.nullable) {
+        schema = schema?.allow(null)
+    }
+
+    if (f?.empty) {
+        schema = schema?.allow('')
+    }
+
+    return schema
+}
+
+
 function buildSchema(col: CollectionType, opts = {
     partial: false
 }) {
@@ -25,130 +162,8 @@ function buildSchema(col: CollectionType, opts = {
         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 == 'slug') {
-                let schema = Joi.string().pattern(/^[a-z0-9]+(?:-[a-z0-9]+)*$/)
-                if (f.slugOptions?.min != null) schema = schema.min(f.slugOptions.min)
-                if (f.slugOptions?.max != null) schema = schema.max(f.slugOptions.max)
-                propertiesSchema[fieldName] = schema
-            }
-
-            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('')
-            }
+            const fieldSchema = fieldToSchema(f)
+            if (fieldSchema) propertiesSchema[fieldName] = fieldSchema
 
         }
     }
@@ -164,4 +179,4 @@ function buildSchemaForkOptional(schemaPassed: AnySchema): AnySchema {
     )
 }
 
-export { buildSchema, buildSchemaForkOptional }
+export { buildSchema, buildSchemaForkOptional, fieldToSchema }

package/database/tenant.ts

@@ -1,6 +1,7 @@
 import type { Tenant } from "../types/tenant";
 import { cfg } from "../server/config";
 import { useRest } from "./rest";
+import { setupAuditCollection, resolveAuditRetention } from "./audit";
 async function syncTenants() {
     try {
         for await (let tenant of cfg.tenants ?? []) {
@@ -17,6 +18,9 @@ async function syncTenants() {
             const { client, db } = await rest.connect()
             tenant.database.client = client
             tenant.database.db = db
+            // One-off audit setup: legacy rename, query indexes, retention
+            // (tenant config wins, `server.audit.retention` is the fallback)
+            await setupAuditCollection(db, resolveAuditRetention(tenant))
         }
     } catch (err: any) {
         console.error('Error bootstrapping tenants', cfg.debug ? err : err?.message)

package/database/ttl.ts

@@ -0,0 +1,68 @@
+import type { Db } from "mongodb";
+import { parseDuration } from "../utils/func";
+
+export type RetentionResult = 'applied' | 'dropped' | 'unchanged' | 'skipped'
+
+/**
+ * Declarative TTL retention for a collection:
+ *
+ * - a duration string (`'90d'`, `'24h'`) → ensure the TTL index with that expiry
+ * - `false`                             → explicitly disabled: drop the TTL index
+ * - omitted                             → untouched
+ *
+ * MongoDB cannot change `expireAfterSeconds` in place through `createIndex`:
+ * `collMod` does it instantly, dropping/recreating is the fallback. Never fatal —
+ * a failure is logged and `'skipped'` is returned.
+ */
+async function syncTtlRetention(
+    db: Db,
+    opts: { collection: string; index: string; field: string; retention?: string | false; label?: string },
+): Promise<RetentionResult> {
+    const { collection, index, field, retention } = opts;
+    const label = opts.label ?? collection;
+
+    if (retention === undefined) return 'skipped';
+
+    const col: any = db.collection(collection);
+
+    try {
+        const existing = (await col.listIndexes().toArray())
+            .find((entry: any) => entry.name === index);
+
+        if (retention === false) {
+            if (!existing) return 'unchanged';
+            await col.dropIndex(index);
+            console.log(`🧹 ${label} retention disabled — ${index} dropped`);
+            return 'dropped';
+        }
+
+        const parsed = parseDuration(retention);
+        if (parsed === null) {
+            console.error(`Invalid ${label} retention '${retention}' — expected a duration like '90d' or '24h'`);
+            return 'skipped';
+        }
+        const expireAfterSeconds = Math.round(parsed / 1000);
+
+        if (!existing) {
+            await col.createIndex({ [field]: 1 }, { name: index, expireAfterSeconds, background: true });
+            console.log(`🧹 ${label} retention enabled — entries expire after ${retention}`);
+            return 'applied';
+        }
+
+        if (existing.expireAfterSeconds === expireAfterSeconds) return 'unchanged';
+
+        try {
+            await db.command({ collMod: collection, index: { name: index, expireAfterSeconds } });
+        } catch {
+            await col.dropIndex(index);
+            await col.createIndex({ [field]: 1 }, { name: index, expireAfterSeconds, background: true });
+        }
+        console.log(`🧹 ${label} retention updated — entries expire after ${retention}`);
+        return 'applied';
+    } catch (err: any) {
+        console.error(`${label} retention failed (${retention})`, err?.message);
+        return 'skipped';
+    }
+}
+
+export { syncTtlRetention }