@ambiten/core 1.0.0

package/dist/gc/gcCron.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gcCron.node.d.ts","sourceRoot":"","sources":["../../src/gc/gcCron.node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAIlC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,YAAY,CAAC;IACnB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,GAAE,MAAM,GAAG,+BAA6C,sBAqDhE"}

package/dist/gc/gcCron.node.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scheduleGarbageCollector = scheduleGarbageCollector;
+const tslib_1 = require("tslib");
+const cron = tslib_1.__importStar(require("node-cron"));
+const gcManager_1 = require("./gcManager");
+const ModelRegistry_1 = require("../utils/ModelRegistry");
+const utils_1 = require("../utils");
+/**
+ * Schedules registry-driven garbage collection.
+ *
+ * The cron task uses registered model instances and delegates cleanup to
+ * `model.runGC()` so Ambiten's runtime context, middleware, schema hooks,
+ * instrumentation, cache invalidation, and events remain centralized.
+ *
+ * @param options - Cron expression or scheduler options.
+ * @returns The scheduled cron task.
+ */
+function scheduleGarbageCollector(options = '0 * * * *') {
+    const cronExpr = typeof options === 'string'
+        ? options
+        : options.cronExpr ?? '0 * * * *';
+    const ctx = typeof options === 'string'
+        ? undefined
+        : options.ctx;
+    const continueOnError = typeof options === 'string'
+        ? true
+        : options.continueOnError ?? true;
+    return cron.schedule(cronExpr, async () => {
+        try {
+            const models = ModelRegistry_1.AmbitenModelRegistry.getAllModels();
+            if (models.length === 0) {
+                console.warn((0, utils_1.colorize)('[GC] Skipping GC: no registered models found.', 'yellow'));
+                return;
+            }
+            console.log((0, utils_1.colorize)(`[GC] Running garbage collector at ${new Date().toISOString()}`, 'blue'));
+            const result = await (0, gcManager_1.runGarbageCollectorOnAllModels)({
+                ctx,
+                continueOnError
+            });
+            console.log((0, utils_1.colorize)(`[GC] Completed. scanned=${result.scanned}, succeeded=${result.succeeded}, failed=${result.failed}`, result.failed > 0 ? 'yellow' : 'blue'));
+        }
+        catch (error) {
+            console.error((0, utils_1.colorize)('[GC] Error running garbage collector', 'red'), error);
+        }
+    });
+}

package/dist/gc/gcManager.d.ts

@@ -0,0 +1,37 @@
+import type { ModelContext } from '../types';
+export interface GarbageCollectorRunOptions {
+    ctx?: ModelContext;
+    continueOnError?: boolean;
+}
+export interface GarbageCollectorModelResult {
+    collectionName?: string;
+    success: boolean;
+    error?: unknown;
+}
+export interface GarbageCollectorRunResult {
+    scanned: number;
+    succeeded: number;
+    failed: number;
+    models: GarbageCollectorModelResult[];
+}
+/**
+ * Runs garbage collection on all registered Ambiten model instances.
+ *
+ * This delegates cleanup to each model's `runGC()` method so the operation
+ * remains context-aware and preserves middleware, schema hooks, query
+ * instrumentation, cache invalidation, and event publishing.
+ *
+ * @param options - Optional garbage collection execution options.
+ * @returns Summary of the garbage collection run.
+ */
+export declare function runGarbageCollectorOnAllModels(options?: GarbageCollectorRunOptions): Promise<GarbageCollectorRunResult>;
+/**
+ * Runs garbage collection on a single Ambiten model instance.
+ *
+ * @param model - Registered Ambiten model instance.
+ * @param ctx - Optional model execution context.
+ */
+export declare function runGarbageCollector(model: {
+    runGC(ctx?: ModelContext): Promise<void>;
+}, ctx?: ModelContext): Promise<void>;
+//# sourceMappingURL=gcManager.d.ts.map

package/dist/gc/gcManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gcManager.d.ts","sourceRoot":"","sources":["../../src/gc/gcManager.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C,MAAM,WAAW,0BAA0B;IACzC,GAAG,CAAC,EAAE,YAAY,CAAC;IACnB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,2BAA2B;IAC1C,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,2BAA2B,EAAE,CAAC;CACvC;AAED;;;;;;;;;GASG;AACH,wBAAsB,8BAA8B,CAClD,OAAO,GAAE,0BAA+B,GACvC,OAAO,CAAC,yBAAyB,CAAC,CAiDpC;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CACvC,KAAK,EAAE;IAAE,KAAK,CAAC,GAAG,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,EACnD,GAAG,CAAC,EAAE,YAAY,GACjB,OAAO,CAAC,IAAI,CAAC,CAEf"}

package/dist/gc/gcManager.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runGarbageCollectorOnAllModels = runGarbageCollectorOnAllModels;
+exports.runGarbageCollector = runGarbageCollector;
+const ModelRegistry_1 = require("../utils/ModelRegistry");
+const utils_1 = require("../utils");
+/**
+ * Runs garbage collection on all registered Ambiten model instances.
+ *
+ * This delegates cleanup to each model's `runGC()` method so the operation
+ * remains context-aware and preserves middleware, schema hooks, query
+ * instrumentation, cache invalidation, and event publishing.
+ *
+ * @param options - Optional garbage collection execution options.
+ * @returns Summary of the garbage collection run.
+ */
+async function runGarbageCollectorOnAllModels(options = {}) {
+    const models = ModelRegistry_1.AmbitenModelRegistry.getAllModels();
+    const result = {
+        scanned: models.length,
+        succeeded: 0,
+        failed: 0,
+        models: []
+    };
+    for (const model of models) {
+        const modelContext = model.getContext?.();
+        const collectionName = modelContext?.ctx?.collectionName;
+        try {
+            if (typeof model.runGC !== 'function') {
+                throw new Error('Registered model does not implement runGC().');
+            }
+            await model.runGC(options.ctx);
+            result.succeeded += 1;
+            result.models.push({
+                collectionName,
+                success: true
+            });
+        }
+        catch (error) {
+            result.failed += 1;
+            result.models.push({
+                collectionName,
+                success: false,
+                error
+            });
+            console.error((0, utils_1.colorize)(`[GC] Failed on collection "${collectionName ?? 'unknown'}"`, 'red'), error);
+            if (!options.continueOnError) {
+                throw error;
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Runs garbage collection on a single Ambiten model instance.
+ *
+ * @param model - Registered Ambiten model instance.
+ * @param ctx - Optional model execution context.
+ */
+async function runGarbageCollector(model, ctx) {
+    await model.runGC(ctx);
+}

package/dist/gc/index.d.ts

@@ -0,0 +1,5 @@
+export * from './ambitenGC';
+export * from './gcCron.node';
+export * from './gcManager';
+export * from './gcCron.browser';
+//# sourceMappingURL=index.d.ts.map

package/dist/gc/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/gc/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC"}

package/dist/gc/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./ambitenGC"), exports);
+tslib_1.__exportStar(require("./gcCron.node"), exports);
+tslib_1.__exportStar(require("./gcManager"), exports);
+tslib_1.__exportStar(require("./gcCron.browser"), exports);

package/dist/graphql/ambitenGraphQL.d.ts

@@ -0,0 +1,24 @@
+import 'dotenv/config';
+import type { GraphQLSchema } from 'graphql';
+import type { AmbitenGraphQLOptions } from '../types';
+export declare class AmbitenGraphQL {
+    private readonly options;
+    private typeDefs;
+    private resolvers;
+    private readonly useRedis;
+    private readonly provider;
+    private subscriber;
+    private publisher;
+    constructor(options: AmbitenGraphQLOptions);
+    customTypeDefs(schema: string | string[]): this;
+    customResolvers(resolver: Record<string, any>): this;
+    private toModelContext;
+    private getCollection;
+    private ensureRedis;
+    private publishEvent;
+    private defaultTypeDefs;
+    private defaultResolvers;
+    subscriptions(): boolean;
+    generateSchema(): Promise<GraphQLSchema>;
+}
+//# sourceMappingURL=ambitenGraphQL.d.ts.map

package/dist/graphql/ambitenGraphQL.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ambitenGraphQL.d.ts","sourceRoot":"","sources":["../../src/graphql/ambitenGraphQL.ts"],"names":[],"mappings":"AAAA,OAAO,eAAe,CAAC;AAGvB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAI7C,OAAO,KAAK,EAIV,qBAAqB,EAEtB,MAAM,UAAU,CAAC;AAGlB,qBAAa,cAAc;IAQb,OAAO,CAAC,QAAQ,CAAC,OAAO;IAPpC,OAAO,CAAC,QAAQ,CAAgB;IAChC,OAAO,CAAC,SAAS,CAAwB;IACzC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAU;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkB;IAC3C,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,SAAS,CAAa;gBAED,OAAO,EAAE,qBAAqB;IAO3D,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI;IAS/C,eAAe,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI;IAKpD,OAAO,CAAC,cAAc;YAYR,aAAa;YAQb,WAAW;YA6BX,YAAY;IAkB1B,OAAO,CAAC,eAAe;IA2BvB,OAAO,CAAC,gBAAgB;IAiIxB,aAAa,IAAI,OAAO;IAIlB,cAAc,IAAI,OAAO,CAAC,aAAa,CAAC;CAQ/C"}

package/dist/graphql/ambitenGraphQL.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmbitenGraphQL = void 0;
+require("dotenv/config");
+const schema_1 = require("@graphql-tools/schema");
+const graphql_tag_1 = require("graphql-tag");
+const mongodb_1 = require("mongodb");
+const redis_manager_1 = require("../redis-manager");
+const utils_1 = require("../utils");
+class AmbitenGraphQL {
+    options;
+    typeDefs = [];
+    resolvers = [];
+    useRedis;
+    provider;
+    subscriber = null;
+    publisher = null;
+    constructor(options) {
+        this.options = options;
+        this.useRedis = options.useRedis !== false;
+        this.typeDefs = options.customTypeDefs ?? [];
+        this.resolvers = options.customResolvers ?? [];
+        this.provider = options.provider;
+    }
+    customTypeDefs(schema) {
+        if (Array.isArray(schema)) {
+            this.typeDefs.push(...schema);
+        }
+        else {
+            this.typeDefs.push(schema);
+        }
+        return this;
+    }
+    customResolvers(resolver) {
+        this.resolvers.push(resolver);
+        return this;
+    }
+    toModelContext(context, collectionName) {
+        return {
+            tenantId: context.tenantId,
+            dbName: context.dbName,
+            collectionName: collectionName ?? context.collectionName,
+            session: context.session
+        };
+    }
+    async getCollection(context, collectionName) {
+        const ctx = this.toModelContext(context, collectionName);
+        return context.provider.collection(collectionName, ctx);
+    }
+    async ensureRedis() {
+        if (!this.useRedis) {
+            return;
+        }
+        const client = await redis_manager_1.redis.get();
+        if (!client) {
+            return;
+        }
+        if (!client.isOpen && typeof client.connect === 'function') {
+            await client.connect();
+        }
+        if (!this.publisher) {
+            this.publisher = typeof client.duplicate === 'function' ? client.duplicate() : client;
+            if (this.publisher?.connect && !this.publisher.isOpen) {
+                await this.publisher.connect();
+            }
+        }
+        if (!this.subscriber) {
+            this.subscriber = typeof client.duplicate === 'function' ? client.duplicate() : client;
+            if (this.subscriber?.connect && !this.subscriber.isOpen) {
+                await this.subscriber.connect();
+            }
+        }
+    }
+    async publishEvent(channel, payload) {
+        if (!this.useRedis) {
+            return;
+        }
+        await this.ensureRedis();
+        const client = await redis_manager_1.redis.get();
+        if (this.publisher?.publish) {
+            await this.publisher.publish(channel, JSON.stringify(payload));
+            return;
+        }
+        if (client?.publish) {
+            await client.publish(channel, JSON.stringify(payload));
+        }
+    }
+    defaultTypeDefs() {
+        return (0, graphql_tag_1.gql) `
+      scalar JSON
+
+      type Document {
+        _id: ID!
+      }
+
+      type Query {
+        findOne(collection: String!, id: ID!): JSON
+        findAll(collection: String!): [JSON!]!
+      }
+
+      type Mutation {
+        insertOne(collection: String!, data: JSON!): JSON
+        updateOne(collection: String!, id: ID!, data: JSON!): JSON
+        deleteOne(collection: String!, id: ID!): Boolean
+      }
+
+      type Subscription {
+        documentInserted(collection: String!): JSON
+        documentUpdated(collection: String!): JSON
+        documentDeleted(collection: String!): JSON
+      }
+    `;
+    }
+    defaultResolvers() {
+        return {
+            Query: {
+                findOne: async (_, { collection, id }, context) => {
+                    const col = await this.getCollection(context, collection);
+                    return col.findOne({ _id: new mongodb_1.ObjectId(id) });
+                },
+                findAll: async (_, { collection }, context) => {
+                    const col = await this.getCollection(context, collection);
+                    return col.find({}).toArray();
+                }
+            },
+            Mutation: {
+                insertOne: async (_, { collection, data }, context) => {
+                    const col = await this.getCollection(context, collection);
+                    const result = await col.insertOne(data);
+                    const newDoc = await col.findOne({ _id: result.insertedId });
+                    await this.publishEvent(`${utils_1.DB_CHANGE_EVENT}`, {
+                        documentInserted: {
+                            action: 'insertOne',
+                            collectionName: collection,
+                            doc: newDoc,
+                            tenantId: context.tenantId
+                        }
+                    });
+                    return newDoc;
+                },
+                updateOne: async (_, { collection, id, data }, context) => {
+                    const col = await this.getCollection(context, collection);
+                    await col.updateOne({ _id: new mongodb_1.ObjectId(id) }, { $set: data });
+                    const updatedDoc = await col.findOne({ _id: new mongodb_1.ObjectId(id) });
+                    await this.publishEvent(`${utils_1.DB_CHANGE_EVENT}`, {
+                        documentUpdated: {
+                            action: 'updateOne',
+                            collectionName: collection,
+                            doc: updatedDoc,
+                            tenantId: context.tenantId
+                        }
+                    });
+                    return updatedDoc;
+                },
+                deleteOne: async (_, { collection, id }, context) => {
+                    const col = await this.getCollection(context, collection);
+                    const result = await col.deleteOne({ _id: new mongodb_1.ObjectId(id) });
+                    if (result.deletedCount === 1) {
+                        await this.publishEvent(`${utils_1.DB_CHANGE_EVENT}`, {
+                            documentDeleted: {
+                                action: 'deleteOne',
+                                collectionName: collection,
+                                id,
+                                tenantId: context.tenantId
+                            }
+                        });
+                        return true;
+                    }
+                    return false;
+                }
+            },
+            Subscription: {
+                documentInserted: {
+                    subscribe: async () => {
+                        if (!this.useRedis) {
+                            return null;
+                        }
+                        await this.ensureRedis();
+                        return this.subscriber;
+                    }
+                },
+                documentUpdated: {
+                    subscribe: async () => {
+                        if (!this.useRedis) {
+                            return null;
+                        }
+                        await this.ensureRedis();
+                        return this.subscriber;
+                    }
+                },
+                documentDeleted: {
+                    subscribe: async () => {
+                        if (!this.useRedis) {
+                            return undefined;
+                        }
+                        await this.ensureRedis();
+                        return this.subscriber;
+                    }
+                }
+            }
+        };
+    }
+    subscriptions() {
+        return this.useRedis;
+    }
+    async generateSchema() {
+        await this.ensureRedis();
+        return (0, schema_1.makeExecutableSchema)({
+            typeDefs: [this.defaultTypeDefs(), ...this.typeDefs],
+            resolvers: [this.defaultResolvers(), ...this.resolvers]
+        });
+    }
+}
+exports.AmbitenGraphQL = AmbitenGraphQL;
+;

package/dist/graphql/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ambitenGraphQL';
+//# sourceMappingURL=index.d.ts.map

package/dist/graphql/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/graphql/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC"}

package/dist/graphql/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./ambitenGraphQL"), exports);