@ambiten/core 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright (c) 2025 Ambiten
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,247 @@
+<div style="display: flex; align-items: center;">
+<p >
+  <img
+    src="https://raw.githubusercontent.com/AmbitenHQ/ambiten/main/assets/ambiten-mark-192x192.png"
+    width="56"
+    alt="Ambiten"
+  />  
+</p> <h2> @ambiten/core</h2>
+</div>
+
+<p align="center">
+  <strong>A runtime and context-aware data platform for MongoDB applications.</strong>
+</p>
+
+<p align="center">
+  Runtime-aware models, transactions, middleware, multi-tenancy, observability, and execution boundaries designed for modern applications.
+</p>
+
+<p align="center">
+<a href="https://www.npmjs.com/package/@ambiten/core">
+  <img src="https://img.shields.io/npm/v/@Ambiten/core?color=0ea5e9&label=npm&style=flat-square" alt="npm version" />
+</a>
+<!-- <a href="https://ambiten.dev">
+  <img src="https://img.shields.io/badge/docs-ambiten.dev-22c55e?style=flat-square" alt="documentation" />
+</a> -->
+  <a href="https://github.com/AmbitenHQ/ambiten/stargazers">
+    <img src="https://img.shields.io/github/stars/AmbitenHQ/ambiten?style=flat-square&color=1E88E5" alt="GitHub stars" />
+  </a>
+<img src="https://img.shields.io/badge/multi--tenant-native-6366f1?style=flat-square" alt="multi-tenant native" />
+<img src="https://img.shields.io/badge/context-aware-14b8a6?style=flat-square" alt="context aware" />
+</p>
+
+---
+
+## Overview
+
+@ambiten/core is the foundation of the Ambiten platform.
+
+It provides the runtime responsible for context propagation, model execution, transaction coordination, multi-tenancy, middleware orchestration, and operational observability across MongoDB applications.
+
+Rather than treating data access as an isolated persistence concern, Ambiten treats execution itself as a runtime responsibility.
+
+The goal is to reduce infrastructure plumbing while keeping execution predictable, observable, and safe under real production conditions.
+
+## What Ambiten Is
+
+Ambiten is not just a MongoDB ODM.
+
+It is a runtime and context-aware execution platform that coordinates context propagation, transactions, multi-tenancy, middleware, instrumentation, and runtime policies across the entire execution lifecycle of an application.
+
+Traditional ODMs focus on mapping data.
+
+Ambiten focuses on coordinating execution.
+
+> Mongoose manages models.
+> Ambiten manages execution.
+
+## Installation
+
+```bash
+npm install @ambiten/core mongodb
+```
+
+```ts
+import {
+  AmbitenClient,
+  AmbitenModel,
+  AmbitenSchema,
+  AmbitenContext
+} from "@ambiten/core";
+
+const client = new AmbitenClient({
+  uri: process.env.MONGODB_URI,
+  options: {
+    dbName: "app"
+  }
+});
+
+await client.connect();
+
+const userSchema = new AmbitenSchema({
+  name: String,
+  email: String
+});
+
+const UserModel = new AmbitenModel({
+  collectionName: "users",
+  schema: userSchema,
+  provider: client
+});
+
+await AmbitenContext.run(
+  {
+    tenantId: "tenant-a",
+    requestId: "req-001"
+  },
+  async () => {
+    await UserModel.create({
+      name: "Alice",
+      email: "alice@example.com"
+    });
+  }
+);
+```
+
+The application code remains focused on product behavior.
+
+The runtime carries execution state.
+
+## Execution Model
+
+Ambiten organizes execution around request-scoped runtime boundaries.
+
+```text
+Request
+  ↓
+Adapter
+  ↓
+AmbitenContext
+  ↓
+Middleware
+  ↓
+AmbitenModel
+  ↓
+Provider / AmbitenClient
+  ↓
+MongoDB
+```
+
+Instead of manually threading tenant IDs, transaction sessions, request metadata, instrumentation payloads, or infrastructure state across services, the runtime keeps execution context attached to the active boundary.
+
+This allows the same execution model to remain consistent across HTTP requests, background workers, queues, scheduled jobs, transactions, and serverless environments.
+
+## Core Capabilities
+
+### Context Runtime
+
+AmbitenContext provides request-scoped runtime state through AsyncLocalStorage.
+
+```ts
+await AmbitenContext.run(
+  {
+    tenantId: "tenant-a"
+  },
+  async () => {
+    await UserModel.find({});
+  }
+);
+```
+
+The active context can carry tenant identity, request metadata, sessions, budgets, runtime observers, instrumentation metadata, and operational state without forcing application services to manually pass them through every execution layer.
+
+### Runtime Models
+
+AmbitenModel provides CRUD and aggregation capabilities that participate directly in the runtime.
+
+```ts
+await UserModel.updateOne(
+  { email: "alice@example.com" },
+  {
+    $set: {
+      active: true
+    }
+  }
+);
+```
+
+Operations can execute inside middleware boundaries, transaction scopes, tenant-aware resolution, instrumentation flows, caching layers, and policy enforcement without departing from familiar MongoDB patterns.
+
+### Multi-Tenancy & Transactions
+
+Tenant isolation and transactional execution are coordinated through the runtime.
+
+```ts
+await AmbitenContext.withTransaction(async () => {
+  await UserModel.create(user);
+  await AuditModel.create(log);
+});
+```
+
+The runtime propagates active sessions automatically while tenant-aware resolution remains attached to the current execution boundary.
+
+Application code stays focused on business logic rather than infrastructure coordination.
+
+### Observability & Instrumentation
+
+Ambiten includes runtime instrumentation through utilities such as `measureQuery()`.
+
+```ts
+await measureQuery(
+  {
+    operation: "find",
+    collectionName: "users"
+  },
+  async () => {
+    return UserModel.find({});
+  }
+);
+```
+
+Instrumentation can expose execution duration, tenant scope, transaction state, cache behavior, collection activity, and operational metadata for downstream observability systems.
+
+## Adapter-Driven Runtime
+
+Ambiten is adapter-driven.
+
+The same runtime model can operate across Express, Fastify, GraphQL systems, NestJS applications, background workers, queues, and serverless environments while preserving consistent execution behavior.
+
+The runtime remains responsible for execution coordination regardless of deployment model.
+
+## Why Ambiten Exists
+
+As applications grow, execution concerns become scattered across services, middleware, repositories, background workers, and infrastructure layers.
+
+Context propagation becomes manual.
+
+Transactions become difficult to coordinate.
+
+Tenant isolation becomes inconsistent.
+
+Observability becomes fragmented.
+
+Ambiten exists to centralize those concerns inside the runtime itself so applications remain focused on business logic while execution behavior stays consistent, observable, and safe.
+
+## Documentation
+
+The official documentation covers runtime architecture, context propagation, transactions, middleware, instrumentation, multi-tenancy, adapters, deployment strategy, and production-oriented workflows.
+
+Documentation:
+
+https://ambiten.dev
+
+## Ecosystem
+
+The Ambiten ecosystem extends beyond the core runtime and includes adapters, logging infrastructure, project scaffolding, GraphQL integration, observability tooling, and future platform capabilities built around the same execution model.
+
+Additional packages continue to evolve around the platform.
+
+## Philosophy
+
+> Execution behavior should be enforced by the runtime, not maintained manually across application code.
+
+Ambiten exists to make systems more predictable, observable, and operationally consistent as complexity grows.
+
+## License
+
+MIT

package/bin/bootstrap.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+/* eslint-disable @typescript-eslint/no-require-imports */
+
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const cliPath = path.resolve(__dirname, '../dist/index-cli.js');
+
+const result = spawnSync(
+  process.execPath,
+  [cliPath, ...process.argv.slice(2)],
+  {
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      Ambiten_DISABLE_SIGNAL_HANDLERS: '1',
+    },
+  }
+);
+
+if (result.error) {
+  console.error('Failed to launch Ambiten CLI:', result.error);
+  process.exit(1);
+}
+
+process.exit(result.status ?? 0);

package/dist/ambiten-cache/ambitenCache.d.ts

@@ -0,0 +1,64 @@
+export interface AmbitenCacheOptions {
+    ttlSeconds?: number;
+    prefix?: string;
+    namespace?: string;
+    tenantId?: string;
+}
+export interface AmbitenCacheClient {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, options?: {
+        EX?: number;
+    }): Promise<unknown>;
+    del(key: string | string[]): Promise<unknown>;
+    scan?(cursor: number, options?: {
+        MATCH?: string;
+        COUNT?: number;
+    }): Promise<[string, string[]] | {
+        cursor: number;
+        keys: string[];
+    }>;
+}
+export declare class AmbitenCache {
+    private readonly client;
+    constructor(client?: AmbitenCacheClient);
+    /**
+     * Builds a tenant-aware cache key.
+     * Key format: {prefix}:{tenantId}:{namespace}:{key}
+     * - prefix: Optional string to namespace cache keys (default: "Ambiten")
+     * - tenantId: Resolved tenant ID for multi-tenancy (explicit > context > "default")
+     * - namespace: Optional string to further namespace keys (default: "cache")
+     * - key: The original cache key provided by the caller
+     *
+     * Resolution priority:
+     * 1. Explicit tenantId from options
+     * 2. Active Ambiten runtime tenantId
+     * 3. "default"
+     */
+    private buildKey;
+    /**
+     * Reads and deserializes a cached value.
+     */
+    get<T>(key: string, options?: AmbitenCacheOptions): Promise<T | null>;
+    /**
+     * Serializes and writes a cached value.
+     */
+    set<T>(key: string, value: T, options?: AmbitenCacheOptions): Promise<void>;
+    /**
+     * Returns cached value if available, otherwise computes, stores, and returns it.
+     */
+    wrap<T>(key: string, fetcher: () => Promise<T>, options?: AmbitenCacheOptions): Promise<T>;
+    /**
+     * Invalidates one cache key.
+     */
+    invalidate(key: string, options?: AmbitenCacheOptions): Promise<void>;
+    /**
+     * Invalidates cache keys by pattern using SCAN.
+     */
+    invalidatePattern(pattern: string): Promise<number>;
+    /**
+     * Internal event hook point for future observability and policy integrations.
+     */
+    private emit;
+}
+export declare function createAmbitenCache(client?: AmbitenCacheClient): AmbitenCache;
+//# sourceMappingURL=ambitenCache.d.ts.map

package/dist/ambiten-cache/ambitenCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ambitenCache.d.ts","sourceRoot":"","sources":["../../src/ambiten-cache/ambitenCache.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,mBAAmB;IAClC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,kBAAkB;IACjC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACzC,GAAG,CACD,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE;QAAE,EAAE,CAAC,EAAE,MAAM,CAAA;KAAE,GACxB,OAAO,CAAC,OAAO,CAAC,CAAC;IACpB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC9C,IAAI,CAAC,CACH,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,GACA,OAAO,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;CACrE;AAED,qBAAa,YAAY;IACX,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,GAAE,kBAA0B;IAE/D;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,QAAQ;IAYhB;;OAEG;IACG,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAmB3E;;OAEG;IACG,GAAG,CAAC,CAAC,EACT,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,CAAC,EACR,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,IAAI,CAAC;IAYhB;;OAEG;IACG,IAAI,CAAC,CAAC,EACV,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACzB,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,CAAC,CAAC;IAab;;OAEG;IACG,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAM3E;;OAEG;IACG,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAyCzD;;OAEG;IACH,OAAO,CAAC,IAAI;CAIb;AAED,wBAAgB,kBAAkB,CAAC,MAAM,GAAE,kBAA0B,GAAG,YAAY,CAEnF"}

package/dist/ambiten-cache/ambitenCache.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmbitenCache = void 0;
+exports.createAmbitenCache = createAmbitenCache;
+const redis_manager_1 = require("../redis-manager");
+const context_1 = require("../context");
+class AmbitenCache {
+    client;
+    constructor(client = redis_manager_1.redis) {
+        this.client = client;
+    }
+    /**
+     * Builds a tenant-aware cache key.
+     * Key format: {prefix}:{tenantId}:{namespace}:{key}
+     * - prefix: Optional string to namespace cache keys (default: "Ambiten")
+     * - tenantId: Resolved tenant ID for multi-tenancy (explicit > context > "default")
+     * - namespace: Optional string to further namespace keys (default: "cache")
+     * - key: The original cache key provided by the caller
+     *
+     * Resolution priority:
+     * 1. Explicit tenantId from options
+     * 2. Active Ambiten runtime tenantId
+     * 3. "default"
+     */
+    buildKey(key, options = {}) {
+        const ctx = context_1.AmbitenContext.get();
+        const prefix = options.prefix ?? 'Ambiten';
+        const tenantId = options.tenantId ?? ctx.tenantId ?? 'default';
+        const namespace = options.namespace ?? 'cache';
+        return [prefix, tenantId, namespace, key]
+            .filter(Boolean)
+            .join(':');
+    }
+    /**
+     * Reads and deserializes a cached value.
+     */
+    async get(key, options) {
+        const namespacedKey = this.buildKey(key, options);
+        const cached = await this.client.get(namespacedKey);
+        if (cached === null || cached === undefined) {
+            this.emit('miss', namespacedKey);
+            return null;
+        }
+        try {
+            this.emit('hit', namespacedKey);
+            return JSON.parse(cached);
+        }
+        catch {
+            await this.client.del(namespacedKey);
+            this.emit('corrupt', namespacedKey);
+            return null;
+        }
+    }
+    /**
+     * Serializes and writes a cached value.
+     */
+    async set(key, value, options = {}) {
+        const namespacedKey = this.buildKey(key, options);
+        await this.client.set(namespacedKey, JSON.stringify(value), { EX: options.ttlSeconds ?? 60 });
+        this.emit('set', namespacedKey);
+    }
+    /**
+     * Returns cached value if available, otherwise computes, stores, and returns it.
+     */
+    async wrap(key, fetcher, options = {}) {
+        const existing = await this.get(key, options);
+        if (existing !== null) {
+            return existing;
+        }
+        const result = await fetcher();
+        await this.set(key, result, options);
+        return result;
+    }
+    /**
+     * Invalidates one cache key.
+     */
+    async invalidate(key, options) {
+        const namespacedKey = this.buildKey(key, options);
+        await this.client.del(namespacedKey);
+        this.emit('invalidate', namespacedKey);
+    }
+    /**
+     * Invalidates cache keys by pattern using SCAN.
+     */
+    async invalidatePattern(pattern) {
+        if (!pattern || typeof pattern !== 'string') {
+            throw new Error('Pattern must be a non-empty string.');
+        }
+        if (!this.client.scan) {
+            throw new Error('Cache client does not support scan().');
+        }
+        let cursor = 0;
+        let deletedCount = 0;
+        do {
+            const result = await this.client.scan(cursor, {
+                MATCH: pattern,
+                COUNT: 100
+            });
+            const nextCursor = Array.isArray(result)
+                ? Number(result[0])
+                : result.cursor;
+            const keys = Array.isArray(result)
+                ? result[1]
+                : result.keys;
+            if (keys.length > 0) {
+                await this.client.del(keys);
+                deletedCount += keys.length;
+            }
+            cursor = nextCursor;
+        } while (cursor !== 0);
+        if (deletedCount > 0) {
+            this.emit('invalidatePattern', pattern);
+        }
+        return deletedCount;
+    }
+    /**
+     * Internal event hook point for future observability and policy integrations.
+     */
+    emit(event, key) {
+        void event;
+        void key;
+    }
+}
+exports.AmbitenCache = AmbitenCache;
+function createAmbitenCache(client = redis_manager_1.redis) {
+    return new AmbitenCache(client);
+}

package/dist/ambiten-cache/index.d.ts

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

package/dist/ambiten-cache/index.d.ts.map

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

package/dist/ambiten-cache/index.js

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

package/dist/browser.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @author Emmanuel Nodolomwanyi - Ambiten Team
+ * @package - @Ambiten/core
+ * @version 1.0.0
+ */
+import { AmbitenClient } from './lib-core';
+declare global {
+    interface Window {
+        AmbitenClient: typeof AmbitenClient;
+        Buffer: any;
+    }
+}
+export * from './lib-core';
+export { AmbitenBootstrapFactory } from './lib-core/bootstrap';
+export * from './config';
+export * from './graphql';
+export * from './tanancy';
+export * from './context';
+export * from './plugins';
+export * from './debug';
+export { measureQueryForBrowser } from './instrumentation';
+export * from './ambiten-cache';
+export * from './utils/builders';
+export * from './utils';
+export * from './gc';
+export * from './redis-manager';
+export * from './types';
+export type { AmbitenRuntime } from './types/ambiten-runtime-type';
+export type { SchemaType } from './types/schema.type';
+export type { Document } from './types/document';
+export type { ErrorType } from './utils/error/errorTypes';
+//# sourceMappingURL=browser.d.ts.map

package/dist/browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../src/browser.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAY3C,OAAO,CAAC,MAAM,CAAC;IACd,UAAU,MAAM;QACf,aAAa,EAAE,OAAO,aAAa,CAAC;QACpC,MAAM,EAAE,GAAG,CAAC;KACZ;CACD;AAOD,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,cAAc,iBAAiB,CAAC;AAGhC,cAAc,kBAAkB,CAAC;AACjC,cAAc,SAAS,CAAC;AACxB,cAAc,MAAM,CAAC;AACrB,cAAc,iBAAiB,CAAC;AAChC,cAAc,SAAS,CAAC;AACxB,YAAY,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,YAAY,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,YAAY,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACjD,YAAY,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/browser.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * @author Emmanuel Nodolomwanyi - Ambiten Team
+ * @package - @Ambiten/core
+ * @version 1.0.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.measureQueryForBrowser = exports.AmbitenBootstrapFactory = void 0;
+const tslib_1 = require("tslib");
+const lib_core_1 = require("./lib-core");
+/**
+ * Ambiten Core Library for Browser
+ * This module provides core functionalities for Ambiten in a browser environment.
+ * It includes database operations, configuration, and more.
+ * @module Ambiten Core Browser Module
+ * @version 1.0.0
+ */
+console.log('Ambiten Core Library Loaded for (Browser)');
+window.AmbitenClient = lib_core_1.AmbitenClient;
+window.Buffer = Buffer;
+tslib_1.__exportStar(require("./lib-core"), exports);
+var bootstrap_1 = require("./lib-core/bootstrap");
+Object.defineProperty(exports, "AmbitenBootstrapFactory", { enumerable: true, get: function () { return bootstrap_1.AmbitenBootstrapFactory; } });
+tslib_1.__exportStar(require("./config"), exports);
+tslib_1.__exportStar(require("./graphql"), exports);
+tslib_1.__exportStar(require("./tanancy"), exports);
+tslib_1.__exportStar(require("./context"), exports);
+tslib_1.__exportStar(require("./plugins"), exports);
+tslib_1.__exportStar(require("./debug"), exports);
+var instrumentation_1 = require("./instrumentation");
+Object.defineProperty(exports, "measureQueryForBrowser", { enumerable: true, get: function () { return instrumentation_1.measureQueryForBrowser; } });
+tslib_1.__exportStar(require("./ambiten-cache"), exports);
+tslib_1.__exportStar(require("./utils/builders"), exports);
+tslib_1.__exportStar(require("./utils"), exports);
+tslib_1.__exportStar(require("./gc"), exports);
+tslib_1.__exportStar(require("./redis-manager"), exports);
+tslib_1.__exportStar(require("./types"), exports);

package/dist/cli/ambiten-core-cli.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+export declare function runBootstrapCLI(argv?: string[]): Promise<void>;
+export default runBootstrapCLI;
+//# sourceMappingURL=ambiten-core-cli.d.ts.map

package/dist/cli/ambiten-core-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ambiten-core-cli.d.ts","sourceRoot":"","sources":["../../src/cli/ambiten-core-cli.ts"],"names":[],"mappings":";AAMA,wBAAsB,eAAe,CAAC,IAAI,WAAe,iBA+BxD;AAED,eAAe,eAAe,CAAC"}

package/dist/cli/ambiten-core-cli.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runBootstrapCLI = runBootstrapCLI;
+const commander_1 = require("commander");
+const generate_project_1 = require("../init-cli/generate.project");
+const buildInteractiveConfig_1 = require("./buildInteractiveConfig");
+async function runBootstrapCLI(argv = process.argv) {
+    const program = new commander_1.Command();
+    program
+        .name('Ambiten')
+        .description('Ambiten CLI')
+        .version('1.0.0', '-v, --version', 'Output the current CLI version');
+    program
+        .command('init')
+        .description('Initialize an Ambiten-powered project')
+        .argument('[projectName]', 'Name of the project')
+        .option('--with-graphql', 'Include GraphQL starter support')
+        .option('--with-redis', 'Enable Redis cache defaults')
+        .option('--logger', 'Enable logger configuration')
+        .option('--multi-tenant', 'Enable multi-tenant mode')
+        .option('--uri <mongodbUri>', 'MongoDB connection URI')
+        .option('--rbac', 'Reserve RBAC feature scaffolding')
+        .option('--with-garbage-collector', 'Enable garbage collector starter files')
+        .option('--install', 'Auto-install dependencies after scaffolding')
+        .action(async (projectName, options) => {
+        try {
+            const config = await (0, buildInteractiveConfig_1.buildInteractiveConfig)(projectName, options);
+            await (0, generate_project_1.generateProject)(config);
+        }
+        catch (error) {
+            console.error('[Ambiten CLI] Failed to initialize project:', error);
+            process.exit(1);
+        }
+    });
+    await program.parseAsync(argv);
+}
+exports.default = runBootstrapCLI;
+if (require.main === module) {
+    void runBootstrapCLI(process.argv);
+}

package/dist/cli/buildInteractiveConfig.d.ts

@@ -0,0 +1,4 @@
+import type { AmbitenConfig } from '../types';
+import type { BootstrapCliOptions } from './types';
+export declare function buildInteractiveConfig(projectNameArg: string | undefined, options: BootstrapCliOptions): Promise<AmbitenConfig>;
+//# sourceMappingURL=buildInteractiveConfig.d.ts.map

package/dist/cli/buildInteractiveConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildInteractiveConfig.d.ts","sourceRoot":"","sources":["../../src/cli/buildInteractiveConfig.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC9C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AA6BnD,wBAAsB,sBAAsB,CAC1C,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,aAAa,CAAC,CAsMxB"}