@objectstack/service-analytics 4.0.4 → 4.1.0

package/src/cube-registry.ts

@@ -1,147 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-import type { Cube } from '@objectstack/spec/data';
-
-/**
- * CubeRegistry — Central registry for analytics cube definitions.
- *
- * Cubes can be registered from two sources:
- * 1. **Manifest definitions** — Explicit cube definitions in `objectstack.config.ts`.
- * 2. **Object schema inference** — Auto-generated cubes from ObjectQL object schemas.
- *
- * The registry is the single source of truth for cube metadata discovery
- * (used by `getMeta()` and the strategy chain).
- */
-export class CubeRegistry {
-  private cubes = new Map<string, Cube>();
-
-  /** Register a single cube definition. Overwrites if name already exists. */
-  register(cube: Cube): void {
-    this.cubes.set(cube.name, cube);
-  }
-
-  /** Register multiple cube definitions at once. */
-  registerAll(cubes: Cube[]): void {
-    for (const cube of cubes) {
-      this.register(cube);
-    }
-  }
-
-  /** Get a cube definition by name. */
-  get(name: string): Cube | undefined {
-    return this.cubes.get(name);
-  }
-
-  /** Check if a cube is registered. */
-  has(name: string): boolean {
-    return this.cubes.has(name);
-  }
-
-  /** Return all registered cubes. */
-  getAll(): Cube[] {
-    return Array.from(this.cubes.values());
-  }
-
-  /** Return all cube names. */
-  names(): string[] {
-    return Array.from(this.cubes.keys());
-  }
-
-  /** Number of registered cubes. */
-  get size(): number {
-    return this.cubes.size;
-  }
-
-  /** Remove all cubes. */
-  clear(): void {
-    this.cubes.clear();
-  }
-
-  /**
-   * Auto-generate a cube definition from an object schema.
-   *
-   * Heuristic rules:
-   * - `number` fields → `sum`, `avg`, `min`, `max` measures
-   * - `boolean` fields → `count` measure (count where true)
-   * - All non-computed fields → dimensions
-   * - `date`/`datetime` fields → time dimensions with standard granularities
-   * - A default `count` measure is always added
-   *
-   * @param objectName - The snake_case object name (used as table/cube name)
-   * @param fields - Array of field descriptors `{ name, type, label? }`
-   */
-  inferFromObject(
-    objectName: string,
-    fields: Array<{ name: string; type: string; label?: string }>,
-  ): Cube {
-    const measures: Record<string, any> = {
-      count: {
-        name: 'count',
-        label: 'Count',
-        type: 'count',
-        sql: '*',
-      },
-    };
-    const dimensions: Record<string, any> = {};
-
-    for (const field of fields) {
-      const label = field.label || field.name;
-
-      // All fields become dimensions
-      const dimType = this.fieldTypeToDimensionType(field.type);
-      dimensions[field.name] = {
-        name: field.name,
-        label,
-        type: dimType,
-        sql: field.name,
-        ...(dimType === 'time'
-          ? { granularities: ['day', 'week', 'month', 'quarter', 'year'] }
-          : {}),
-      };
-
-      // Numeric fields also become aggregation measures
-      if (field.type === 'number' || field.type === 'currency' || field.type === 'percent') {
-        measures[`${field.name}_sum`] = {
-          name: `${field.name}_sum`,
-          label: `${label} (Sum)`,
-          type: 'sum',
-          sql: field.name,
-        };
-        measures[`${field.name}_avg`] = {
-          name: `${field.name}_avg`,
-          label: `${label} (Avg)`,
-          type: 'avg',
-          sql: field.name,
-        };
-      }
-    }
-
-    const cube: Cube = {
-      name: objectName,
-      title: objectName,
-      sql: objectName,
-      measures,
-      dimensions,
-      public: false,
-    };
-
-    this.register(cube);
-    return cube;
-  }
-
-  private fieldTypeToDimensionType(fieldType: string): string {
-    switch (fieldType) {
-      case 'number':
-      case 'currency':
-      case 'percent':
-        return 'number';
-      case 'boolean':
-        return 'boolean';
-      case 'date':
-      case 'datetime':
-        return 'time';
-      default:
-        return 'string';
-    }
-  }
-}

package/src/index.ts

@@ -1,19 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-// Core service
-export { AnalyticsService } from './analytics-service.js';
-export type { AnalyticsServiceConfig } from './analytics-service.js';
-
-// Kernel plugin
-export { AnalyticsServicePlugin } from './plugin.js';
-export type { AnalyticsServicePluginOptions } from './plugin.js';
-
-// Cube registry
-export { CubeRegistry } from './cube-registry.js';
-
-// Strategies
-export { NativeSQLStrategy } from './strategies/native-sql-strategy.js';
-export { ObjectQLStrategy } from './strategies/objectql-strategy.js';
-export type { AnalyticsStrategy, StrategyContext, DriverCapabilities } from './strategies/types.js';
-
-// Note: InMemoryStrategy is exported from @objectstack/driver-memory

package/src/plugin.ts

@@ -1,133 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-import type { Plugin, PluginContext } from '@objectstack/core';
-import type { Cube } from '@objectstack/spec/data';
-import type { IAnalyticsService } from '@objectstack/spec/contracts';
-import { AnalyticsService } from './analytics-service.js';
-import type { AnalyticsServiceConfig } from './analytics-service.js';
-import type { DriverCapabilities } from './strategies/types.js';
-
-/**
- * Configuration for AnalyticsServicePlugin.
- */
-export interface AnalyticsServicePluginOptions {
-  /** Pre-defined cube definitions (from manifest). */
-  cubes?: Cube[];
-  /**
-   * Probe driver capabilities for a given cube.
-   * When omitted, defaults to in-memory only.
-   */
-  queryCapabilities?: (cubeName: string) => DriverCapabilities;
-  /**
-   * Execute raw SQL on a driver. Enables NativeSQLStrategy.
-   */
-  executeRawSql?: (objectName: string, sql: string, params: unknown[]) => Promise<Record<string, unknown>[]>;
-  /**
-   * Execute ObjectQL aggregate. Enables ObjectQLStrategy.
-   */
-  executeAggregate?: (objectName: string, options: {
-    groupBy?: string[];
-    aggregations?: Array<{ field: string; method: string; alias: string }>;
-    filter?: Record<string, unknown>;
-  }) => Promise<Record<string, unknown>[]>;
-  /** Enable debug logging. */
-  debug?: boolean;
-}
-
-/**
- * AnalyticsServicePlugin — Kernel plugin for multi-driver analytics.
- *
- * Lifecycle:
- * 1. **init** — Creates `AnalyticsService`, registers as `'analytics'` service.
- *    If an existing analytics service is already registered (e.g. MemoryAnalyticsService
- *    from dev-plugin), it is captured as the `fallbackService`.
- * 2. **start** — Triggers `'analytics:ready'` hook so other plugins can
- *    register cubes or extend the service.
- * 3. **destroy** — Cleans up references.
- *
- * @example
- * ```ts
- * import { LiteKernel } from '@objectstack/core';
- * import { AnalyticsServicePlugin } from '@objectstack/service-analytics';
- *
- * const kernel = new LiteKernel();
- * kernel.use(new AnalyticsServicePlugin({
- *   cubes: [ordersCube],
- *   queryCapabilities: (cube) => ({ nativeSql: true, objectqlAggregate: true, inMemory: false }),
- *   executeRawSql: async (obj, sql, params) => pgPool.query(sql, params).then(r => r.rows),
- * }));
- * await kernel.bootstrap();
- *
- * const analytics = kernel.getService<IAnalyticsService>('analytics');
- * const result = await analytics.query({ cube: 'orders', measures: ['orders.count'] });
- * ```
- */
-export class AnalyticsServicePlugin implements Plugin {
-  name = 'com.objectstack.service-analytics';
-  version = '1.0.0';
-  type = 'standard' as const;
-  dependencies: string[] = [];
-
-  private service?: AnalyticsService;
-  private readonly options: AnalyticsServicePluginOptions;
-
-  constructor(options: AnalyticsServicePluginOptions = {}) {
-    this.options = options;
-  }
-
-  async init(ctx: PluginContext): Promise<void> {
-    // Check if there is an existing analytics service (e.g. from dev-plugin)
-    let fallbackService: IAnalyticsService | undefined;
-    try {
-      const existing = ctx.getService<IAnalyticsService>('analytics');
-      if (existing && typeof existing.query === 'function') {
-        fallbackService = existing;
-        ctx.logger.debug('[Analytics] Found existing analytics service, using as fallback');
-      }
-    } catch {
-      // No existing service — that's fine
-    }
-
-    const config: AnalyticsServiceConfig = {
-      cubes: this.options.cubes,
-      logger: ctx.logger,
-      queryCapabilities: this.options.queryCapabilities,
-      executeRawSql: this.options.executeRawSql,
-      executeAggregate: this.options.executeAggregate,
-      fallbackService,
-    };
-
-    this.service = new AnalyticsService(config);
-
-    // Register or replace the analytics service
-    if (fallbackService) {
-      ctx.replaceService('analytics', this.service);
-    } else {
-      ctx.registerService('analytics', this.service);
-    }
-
-    if (this.options.debug) {
-      ctx.hook('analytics:beforeQuery', async (query: unknown) => {
-        ctx.logger.debug('[Analytics] Before query', { query });
-      });
-    }
-
-    ctx.logger.info('[Analytics] Service initialized');
-  }
-
-  async start(ctx: PluginContext): Promise<void> {
-    if (!this.service) return;
-
-    // Notify other plugins that analytics is ready
-    await ctx.trigger('analytics:ready', this.service);
-
-    ctx.logger.info(
-      `[Analytics] Service started with ${this.service.cubeRegistry.size} cubes: ` +
-      `${this.service.cubeRegistry.names().join(', ') || '(none)'}`,
-    );
-  }
-
-  async destroy(): Promise<void> {
-    this.service = undefined;
-  }
-}

package/src/strategies/native-sql-strategy.ts

@@ -1,184 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-import type { AnalyticsQuery, AnalyticsResult } from '@objectstack/spec/contracts';
-import type { Cube } from '@objectstack/spec/data';
-import type { AnalyticsStrategy, StrategyContext } from './types.js';
-
-/**
- * NativeSQLStrategy — Priority 1
- *
- * Pushes the analytics query down to the database as a native SQL statement.
- * This is the most efficient path and is preferred whenever the backing driver
- * supports raw SQL execution (e.g. Postgres, MySQL, SQLite).
- */
-export class NativeSQLStrategy implements AnalyticsStrategy {
-  readonly name = 'NativeSQLStrategy';
-  readonly priority = 10;
-
-  canHandle(query: AnalyticsQuery, ctx: StrategyContext): boolean {
-    if (!query.cube) return false;
-    const caps = ctx.queryCapabilities(query.cube);
-    return caps.nativeSql && typeof ctx.executeRawSql === 'function';
-  }
-
-  async execute(query: AnalyticsQuery, ctx: StrategyContext): Promise<AnalyticsResult> {
-    const { sql, params } = await this.generateSql(query, ctx);
-    const cube = ctx.getCube(query.cube!)!;
-    const objectName = this.extractObjectName(cube);
-
-    const rows = await ctx.executeRawSql!(objectName, sql, params);
-
-    // Build field metadata
-    const fields = this.buildFieldMeta(query, cube);
-
-    return { rows, fields, sql };
-  }
-
-  async generateSql(query: AnalyticsQuery, ctx: StrategyContext): Promise<{ sql: string; params: unknown[] }> {
-    const cube = ctx.getCube(query.cube!);
-    if (!cube) {
-      throw new Error(`Cube not found: ${query.cube}`);
-    }
-
-    const params: unknown[] = [];
-    const selectClauses: string[] = [];
-    const groupByClauses: string[] = [];
-
-    // Build SELECT for dimensions
-    if (query.dimensions && query.dimensions.length > 0) {
-      for (const dim of query.dimensions) {
-        const colExpr = this.resolveDimensionSql(cube, dim);
-        selectClauses.push(`${colExpr} AS "${dim}"`);
-        groupByClauses.push(colExpr);
-      }
-    }
-
-    // Build SELECT for measures
-    if (query.measures && query.measures.length > 0) {
-      for (const measure of query.measures) {
-        const aggExpr = this.resolveMeasureSql(cube, measure);
-        selectClauses.push(`${aggExpr} AS "${measure}"`);
-      }
-    }
-
-    // Build WHERE clause
-    const whereClauses: string[] = [];
-    if (query.filters && query.filters.length > 0) {
-      for (const filter of query.filters) {
-        const colExpr = this.resolveFieldSql(cube, filter.member);
-        const clause = this.buildFilterClause(colExpr, filter.operator, filter.values, params);
-        if (clause) whereClauses.push(clause);
-      }
-    }
-
-    // Build time dimension filters
-    if (query.timeDimensions && query.timeDimensions.length > 0) {
-      for (const td of query.timeDimensions) {
-        const colExpr = this.resolveFieldSql(cube, td.dimension);
-        if (td.dateRange) {
-          const range = Array.isArray(td.dateRange) ? td.dateRange : [td.dateRange, td.dateRange];
-          if (range.length === 2) {
-            params.push(range[0], range[1]);
-            whereClauses.push(`${colExpr} BETWEEN $${params.length - 1} AND $${params.length}`);
-          }
-        }
-      }
-    }
-
-    const tableName = this.extractObjectName(cube);
-    let sql = `SELECT ${selectClauses.join(', ')} FROM "${tableName}"`;
-    if (whereClauses.length > 0) {
-      sql += ` WHERE ${whereClauses.join(' AND ')}`;
-    }
-    if (groupByClauses.length > 0) {
-      sql += ` GROUP BY ${groupByClauses.join(', ')}`;
-    }
-    if (query.order && Object.keys(query.order).length > 0) {
-      const orderClauses = Object.entries(query.order).map(([f, d]) => `"${f}" ${d.toUpperCase()}`);
-      sql += ` ORDER BY ${orderClauses.join(', ')}`;
-    }
-    if (query.limit != null) {
-      sql += ` LIMIT ${query.limit}`;
-    }
-    if (query.offset != null) {
-      sql += ` OFFSET ${query.offset}`;
-    }
-
-    return { sql, params };
-  }
-
-  // ── Helpers ──────────────────────────────────────────────────────
-
-  private resolveDimensionSql(cube: Cube, member: string): string {
-    const fieldName = member.includes('.') ? member.split('.')[1] : member;
-    const dim = cube.dimensions[fieldName];
-    return dim ? dim.sql : fieldName;
-  }
-
-  private resolveMeasureSql(cube: Cube, member: string): string {
-    const fieldName = member.includes('.') ? member.split('.')[1] : member;
-    const measure = cube.measures[fieldName];
-    if (!measure) return `COUNT(*)`;
-
-    const col = measure.sql;
-    switch (measure.type) {
-      case 'count': return 'COUNT(*)';
-      case 'sum': return `SUM(${col})`;
-      case 'avg': return `AVG(${col})`;
-      case 'min': return `MIN(${col})`;
-      case 'max': return `MAX(${col})`;
-      case 'count_distinct': return `COUNT(DISTINCT ${col})`;
-      default: return `COUNT(*)`;
-    }
-  }
-
-  private resolveFieldSql(cube: Cube, member: string): string {
-    const fieldName = member.includes('.') ? member.split('.')[1] : member;
-    const dim = cube.dimensions[fieldName];
-    if (dim) return dim.sql;
-    const measure = cube.measures[fieldName];
-    if (measure) return measure.sql;
-    return fieldName;
-  }
-
-  private buildFilterClause(col: string, operator: string, values: string[] | undefined, params: unknown[]): string | null {
-    const opMap: Record<string, string> = {
-      equals: '=', notEquals: '!=', gt: '>', gte: '>=', lt: '<', lte: '<=',
-      contains: 'LIKE', notContains: 'NOT LIKE',
-    };
-
-    if (operator === 'set') return `${col} IS NOT NULL`;
-    if (operator === 'notSet') return `${col} IS NULL`;
-
-    const sqlOp = opMap[operator];
-    if (!sqlOp || !values || values.length === 0) return null;
-
-    if (operator === 'contains' || operator === 'notContains') {
-      params.push(`%${values[0]}%`);
-    } else {
-      params.push(values[0]);
-    }
-    return `${col} ${sqlOp} $${params.length}`;
-  }
-
-  private extractObjectName(cube: Cube): string {
-    return cube.sql.trim();
-  }
-
-  private buildFieldMeta(query: AnalyticsQuery, cube: Cube): Array<{ name: string; type: string }> {
-    const fields: Array<{ name: string; type: string }> = [];
-    if (query.dimensions) {
-      for (const dim of query.dimensions) {
-        const fieldName = dim.includes('.') ? dim.split('.')[1] : dim;
-        const d = cube.dimensions[fieldName];
-        fields.push({ name: dim, type: d?.type || 'string' });
-      }
-    }
-    if (query.measures) {
-      for (const m of query.measures) {
-        fields.push({ name: m, type: 'number' });
-      }
-    }
-    return fields;
-  }
-}

package/src/strategies/objectql-strategy.ts

@@ -1,178 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-import type { AnalyticsQuery, AnalyticsResult } from '@objectstack/spec/contracts';
-import type { Cube } from '@objectstack/spec/data';
-import type { AnalyticsStrategy, StrategyContext } from './types.js';
-
-/**
- * ObjectQLStrategy — Priority 2
- *
- * Translates an analytics query into an ObjectQL `engine.aggregate()` call.
- * This path works with any driver that supports the ObjectQL aggregate AST
- * (Postgres, Mongo, SQLite, etc.) without requiring raw SQL access.
- */
-export class ObjectQLStrategy implements AnalyticsStrategy {
-  readonly name = 'ObjectQLStrategy';
-  readonly priority = 20;
-
-  canHandle(query: AnalyticsQuery, ctx: StrategyContext): boolean {
-    if (!query.cube) return false;
-    const caps = ctx.queryCapabilities(query.cube);
-    return caps.objectqlAggregate && typeof ctx.executeAggregate === 'function';
-  }
-
-  async execute(query: AnalyticsQuery, ctx: StrategyContext): Promise<AnalyticsResult> {
-    const cube = ctx.getCube(query.cube!)!;
-    const objectName = this.extractObjectName(cube);
-
-    // Build groupBy from dimensions
-    const groupBy: string[] = [];
-    if (query.dimensions && query.dimensions.length > 0) {
-      for (const dim of query.dimensions) {
-        groupBy.push(this.resolveFieldName(cube, dim, 'dimension'));
-      }
-    }
-
-    // Build aggregations from measures
-    const aggregations: Array<{ field: string; method: string; alias: string }> = [];
-    if (query.measures && query.measures.length > 0) {
-      for (const measure of query.measures) {
-        const { field, method } = this.resolveMeasureAggregation(cube, measure);
-        aggregations.push({ field, method, alias: measure });
-      }
-    }
-
-    // Build filter from query filters
-    const filter: Record<string, unknown> = {};
-    if (query.filters && query.filters.length > 0) {
-      for (const f of query.filters) {
-        const fieldName = this.resolveFieldName(cube, f.member, 'any');
-        filter[fieldName] = this.convertFilter(f.operator, f.values);
-      }
-    }
-
-    const rows = await ctx.executeAggregate!(objectName, {
-      groupBy: groupBy.length > 0 ? groupBy : undefined,
-      aggregations: aggregations.length > 0 ? aggregations : undefined,
-      filter: Object.keys(filter).length > 0 ? filter : undefined,
-    });
-
-    // Remap short field names back to cube-qualified names
-    const mappedRows = rows.map(row => {
-      const mapped: Record<string, unknown> = {};
-      if (query.dimensions) {
-        for (const dim of query.dimensions) {
-          const shortName = this.resolveFieldName(cube, dim, 'dimension');
-          if (shortName in row) mapped[dim] = row[shortName];
-        }
-      }
-      if (query.measures) {
-        for (const m of query.measures) {
-          // Alias was set to the full measure name
-          if (m in row) mapped[m] = row[m];
-        }
-      }
-      return mapped;
-    });
-
-    const fields = this.buildFieldMeta(query, cube);
-    return { rows: mappedRows, fields };
-  }
-
-  async generateSql(query: AnalyticsQuery, ctx: StrategyContext): Promise<{ sql: string; params: unknown[] }> {
-    const cube = ctx.getCube(query.cube!);
-    if (!cube) {
-      throw new Error(`Cube not found: ${query.cube}`);
-    }
-
-    // Generate a representative SQL even though ObjectQL uses AST internally
-    const selectParts: string[] = [];
-    const groupByParts: string[] = [];
-
-    if (query.dimensions) {
-      for (const dim of query.dimensions) {
-        const col = this.resolveFieldName(cube, dim, 'dimension');
-        selectParts.push(`${col} AS "${dim}"`);
-        groupByParts.push(col);
-      }
-    }
-    if (query.measures) {
-      for (const m of query.measures) {
-        const { field, method } = this.resolveMeasureAggregation(cube, m);
-        const aggSql = method === 'count' ? 'COUNT(*)' : `${method.toUpperCase()}(${field})`;
-        selectParts.push(`${aggSql} AS "${m}"`);
-      }
-    }
-
-    const tableName = this.extractObjectName(cube);
-    let sql = `SELECT ${selectParts.join(', ')} FROM "${tableName}"`;
-    if (groupByParts.length > 0) {
-      sql += ` GROUP BY ${groupByParts.join(', ')}`;
-    }
-
-    return { sql, params: [] };
-  }
-
-  // ── Helpers ──────────────────────────────────────────────────────
-
-  private resolveFieldName(cube: Cube, member: string, kind: 'dimension' | 'measure' | 'any'): string {
-    const fieldName = member.includes('.') ? member.split('.')[1] : member;
-    if (kind === 'dimension' || kind === 'any') {
-      const dim = cube.dimensions[fieldName];
-      if (dim) return dim.sql.replace(/^\$/, '');
-    }
-    if (kind === 'measure' || kind === 'any') {
-      const measure = cube.measures[fieldName];
-      if (measure) return measure.sql.replace(/^\$/, '');
-    }
-    return fieldName;
-  }
-
-  private resolveMeasureAggregation(cube: Cube, measureName: string): { field: string; method: string } {
-    const fieldName = measureName.includes('.') ? measureName.split('.')[1] : measureName;
-    const measure = cube.measures[fieldName];
-    if (!measure) return { field: '*', method: 'count' };
-    return {
-      field: measure.sql.replace(/^\$/, ''),
-      method: measure.type === 'count_distinct' ? 'count_distinct' : measure.type,
-    };
-  }
-
-  private convertFilter(operator: string, values?: string[]): unknown {
-    if (operator === 'set') return { $ne: null };
-    if (operator === 'notSet') return null;
-    if (!values || values.length === 0) return undefined;
-
-    switch (operator) {
-      case 'equals': return values[0];
-      case 'notEquals': return { $ne: values[0] };
-      case 'gt': return { $gt: values[0] };
-      case 'gte': return { $gte: values[0] };
-      case 'lt': return { $lt: values[0] };
-      case 'lte': return { $lte: values[0] };
-      case 'contains': return { $regex: values[0] };
-      default: return values[0];
-    }
-  }
-
-  private extractObjectName(cube: Cube): string {
-    return cube.sql.trim();
-  }
-
-  private buildFieldMeta(query: AnalyticsQuery, cube: Cube): Array<{ name: string; type: string }> {
-    const fields: Array<{ name: string; type: string }> = [];
-    if (query.dimensions) {
-      for (const dim of query.dimensions) {
-        const fieldName = dim.includes('.') ? dim.split('.')[1] : dim;
-        const d = cube.dimensions[fieldName];
-        fields.push({ name: dim, type: d?.type || 'string' });
-      }
-    }
-    if (query.measures) {
-      for (const m of query.measures) {
-        fields.push({ name: m, type: 'number' });
-      }
-    }
-    return fields;
-  }
-}

package/src/strategies/types.ts

@@ -1,11 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-/**
- * Strategy pattern types — re-exported from @objectstack/spec/contracts
- * for convenience. The canonical definitions live in the spec package.
- */
-export type {
-  AnalyticsStrategy,
-  StrategyContext,
-  DriverCapabilities,
-} from '@objectstack/spec/contracts';

package/tsconfig.json

@@ -1,17 +0,0 @@
-{
-  "extends": "../../../tsconfig.json",
-  "compilerOptions": {
-    "outDir": "dist",
-    "rootDir": "src",
-    "types": [
-      "node"
-    ]
-  },
-  "include": [
-    "src"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist"
-  ]
-}