web3ql-client 1.2.0

package/src/typed-table.ts

@@ -0,0 +1,340 @@
+/**
+ * @file   typed-table.ts
+ * @notice High-level Prisma-style API for Web3QL encrypted tables.
+ *
+ * v1.1 upgrades:
+ *   • Optional SchemaDefinition support — auto validates, encodes, and decodes
+ *     fields using the extended type system (TIMESTAMP, UUID, ENUM, DECIMAL, etc.)
+ *   • NOT NULL + DEFAULT enforcement on write
+ *   • findMany with full query builder support: where/orderBy/limit/select/distinct
+ *   • findAll — convenience method (fetches + decrypts all records in batches)
+ *   • aggregate — COUNT/SUM/AVG/MIN/MAX over filtered decrypted records
+ *   • seed — bulk insert an array of records
+ *
+ * Usage (basic, schema-less — identical to v1.0):
+ * ─────────────────────────────────────────────────────────────
+ *   const users = new TypedTableClient<User>('users', db.table('0xTABLE'))
+ *   await users.create(1n, { id: 1n, name: 'Alice' })
+ *   const alice = await users.findUnique(1n)
+ *
+ * Usage (with schema for validation + type coercion):
+ * ─────────────────────────────────────────────────────────────
+ *   const schema: SchemaDefinition = [
+ *     { name: 'id',        type: 'INT',       primaryKey: true },
+ *     { name: 'name',      type: 'TEXT',       notNull: true },
+ *     { name: 'email',     type: 'TEXT',       notNull: true },
+ *     { name: 'createdAt', type: 'TIMESTAMP',  default: () => new Date() },
+ *     { name: 'role',      type: 'ENUM',       enumValues: ['user','admin'], default: 'user' },
+ *   ]
+ *   const users = new TypedTableClient<User>('users', db.table('0xADDR'), schema)
+ *
+ *   // findMany with query builder
+ *   const admins = await users.findMany(ownerAddr, {
+ *     where:   [['role', 'eq', 'admin']],
+ *     orderBy: [['createdAt', 'desc']],
+ *     limit:   20,
+ *     select:  ['id', 'name', 'email'],
+ *   })
+ * ─────────────────────────────────────────────────────────────
+ */
+
+import { ethers }                    from 'ethers';
+import type { EncryptedTableClient } from './table-client.js';
+import {
+  SchemaDefinition,
+  validateAndEncode,
+  decodeRow,
+}                                    from './types.js';
+import {
+  query as buildQuery,
+  WhereOperator,
+  SortDirection,
+  AggregateOptions,
+  AggregateResult,
+}                                    from './query.js';
+
+export type { SchemaDefinition }     from './types.js';
+
+// ─────────────────────────────────────────────────────────────
+//  Public API types
+// ─────────────────────────────────────────────────────────────
+
+/** A single WHERE clause expressed as a tuple. */
+export type WhereTuple =
+  | [field: string, op: 'isNull' | 'isNotNull']
+  | [field: string, op: 'in' | 'notIn',        values: unknown[]]
+  | [field: string, op: 'between',              range: [unknown, unknown]]
+  | [field: string, op: WhereOperator,          value: unknown];
+
+export interface FindManyOptions {
+  /**
+   * Starting index into the owner's record list when fetching from chain.
+   * Applied BEFORE client-side filtering — increase if paginating large tables.
+   * Default: 0.
+   */
+  chainOffset?: bigint;
+  /**
+   * Maximum records to fetch from chain per page.
+   * Default: 200 (raised from v1.0's 50 to allow client-side filtering).
+   */
+  chainLimit?: bigint;
+  /** WHERE conditions — ANDed together. Applied after decrypt. */
+  where?: WhereTuple[];
+  /** Sort order — applied after filtering. */
+  orderBy?: [field: string, dir?: SortDirection][];
+  /** Max records returned after filtering (client-side LIMIT). */
+  limit?: number;
+  /** Skip N records after filtering (client-side OFFSET). */
+  offset?: number;
+  /** Return only these fields. */
+  select?: string[];
+  /** Deduplicate on this field value. */
+  distinct?: string;
+}
+
+export interface RecordWithId<T> {
+  /**
+   * The uint256 primary key cannot be recovered from the on-chain bytes32 key alone
+   * (it is a keccak256 hash). This field is always `0n` when records are fetched via
+   * `findMany()`. Store the primary key inside your data payload and read it from
+   * `record.data.id` instead.
+   */
+  id       : bigint;
+  /** Decrypted, typed record data. */
+  data     : T;
+  /** bytes32 on-chain key (hex string). */
+  recordKey: string;
+}
+
+// ─────────────────────────────────────────────────────────────
+//  TypedTableClient
+// ─────────────────────────────────────────────────────────────
+
+export class TypedTableClient<T extends Record<string, unknown>> {
+  private tableName : string;
+  private inner     : EncryptedTableClient;
+  private schema?   : SchemaDefinition;
+
+  /**
+   * @param tableName  Must match the name used in the SQL schema and createTable().
+   * @param inner      An EncryptedTableClient from DatabaseClient.table(address).
+   * @param schema     Optional field descriptors — enables validation, type coercion,
+   *                   NOT NULL enforcement, and DEFAULT values.
+   */
+  constructor(tableName: string, inner: EncryptedTableClient, schema?: SchemaDefinition) {
+    this.tableName = tableName;
+    this.inner     = inner;
+    this.schema    = schema;
+  }
+
+  // ── Key helper ─────────────────────────────────────────────
+
+  /** Derive the canonical bytes32 on-chain key for a given primary key id. */
+  key(id: bigint): string {
+    return this.inner.deriveKey(this.tableName, id);
+  }
+
+  // ── Internal encode/decode ──────────────────────────────────
+
+  private encode(data: T): string {
+    if (this.schema) {
+      const wire = validateAndEncode(this.schema, data as Record<string, unknown>);
+      return JSON.stringify(wire);
+    }
+    return JSON.stringify(data);
+  }
+
+  private decode(plaintext: string): T {
+    const parsed = JSON.parse(plaintext) as Record<string, unknown>;
+    if (this.schema) return decodeRow(this.schema, parsed) as T;
+    return parsed as T;
+  }
+
+  // ── Write ───────────────────────────────────────────────────
+
+  /**
+   * Validate, encode, encrypt, and store a new record.
+   * Throws if a non-deleted record with the same id already exists.
+   */
+  async create(id: bigint, data: T): Promise<ethers.TransactionReceipt> {
+    return this.inner.writeRaw(this.key(id), this.encode(data));
+  }
+
+  /**
+   * Bulk-insert an array of records. Each record must include the primary key field.
+   * Records are written sequentially — fails on first error.
+   */
+  async seed(
+    rows: { id: bigint; data: T }[],
+  ): Promise<ethers.TransactionReceipt[]> {
+    const receipts: ethers.TransactionReceipt[] = [];
+    for (const row of rows) {
+      receipts.push(await this.create(row.id, row.data));
+    }
+    return receipts;
+  }
+
+  // ── Read ────────────────────────────────────────────────────
+
+  /**
+   * Read and decrypt a single record by primary key.
+   * Returns `null` if the record does not exist or has been deleted.
+   */
+  async findUnique(id: bigint): Promise<T | null> {
+    try {
+      const exists = await this.inner.exists(this.key(id));
+      if (!exists) return null;
+      const plaintext = await this.inner.readPlaintext(this.key(id));
+      return this.decode(plaintext);
+    } catch (err: unknown) {
+      const msg = (err as Error).message ?? '';
+      if (msg.includes('deleted') || msg.includes('not found') || msg.includes('RecordMeta')) {
+        return null;
+      }
+      throw err;
+    }
+  }
+
+  /**
+   * List and decrypt all records owned by `ownerAddress`, with optional
+   * client-side filtering, sorting, pagination, and projection.
+   *
+   * ⚠  Records are decrypted client-side. Use `chainLimit` to constrain
+   *    chain reads on large tables. For production scale, use the relay-
+   *    maintained index endpoint (v1.2) instead.
+   */
+  async findMany(
+    ownerAddress : string,
+    options      : FindManyOptions = {},
+  ): Promise<RecordWithId<Partial<T>>[]> {
+    const chainOffset = options.chainOffset ?? 0n;
+    const chainLimit  = options.chainLimit  ?? 200n;
+
+    const keys: string[] = await this.inner.listOwnerRecords(ownerAddress, chainOffset, chainLimit);
+    const raw: RecordWithId<T>[] = [];
+
+    // Decrypt in parallel (capped at 20 concurrent RPCs)
+    const BATCH = 20;
+    for (let i = 0; i < keys.length; i += BATCH) {
+      const batch = keys.slice(i, i + BATCH);
+      const settled = await Promise.allSettled(
+        batch.map(async (recordKey) => {
+          const plaintext = await this.inner.readPlaintext(recordKey);
+          return { id: 0n, data: this.decode(plaintext), recordKey };
+        }),
+      );
+      for (const r of settled) {
+        if (r.status === 'fulfilled') raw.push(r.value);
+        // silently skip inaccessible / deleted records
+      }
+    }
+
+    // Build query
+    let q = buildQuery(raw.map((r) => r.data as Record<string, unknown>));
+
+    if (options.where) {
+      for (const clause of options.where) {
+        if (clause[1] === 'isNull' || clause[1] === 'isNotNull') {
+          q = q.where(clause[0], clause[1]);
+        } else if (clause[1] === 'in' || clause[1] === 'notIn') {
+          q = q.where(clause[0], clause[1], clause[2] as unknown[]);
+        } else if (clause[1] === 'between') {
+          q = q.where(clause[0], clause[1], clause[2] as [unknown, unknown]);
+        } else {
+          q = q.where(clause[0], clause[1] as WhereOperator, clause[2]);
+        }
+      }
+    }
+    if (options.orderBy) {
+      for (const [field, dir] of options.orderBy) q = q.orderBy(field, dir ?? 'asc');
+    }
+    if (options.limit  != null) q = q.limit(options.limit);
+    if (options.offset != null) q = q.offset(options.offset);
+    if (options.select)         q = q.select(options.select);
+    if (options.distinct)       q = q.distinct(options.distinct);
+
+    const filteredData = q.execute() as Partial<T>[];
+
+    // Remap back to RecordWithId — match by index since we decrypted in order
+    return filteredData.map((data, idx) => ({
+      id       : 0n,
+      data,
+      recordKey: raw[idx]?.recordKey ?? '',
+    }));
+  }
+
+  /**
+   * Convenience: fetch and decrypt ALL records the wallet owns (no chain limit).
+   * Useful for small tables or full exports. Decrypts in parallel batches of 20.
+   */
+  async findAll(ownerAddress: string): Promise<RecordWithId<T>[]> {
+    const total = Number(await this.inner.ownerRecordCount(ownerAddress));
+    return this.findMany(ownerAddress, {
+      chainOffset: 0n,
+      chainLimit : BigInt(total),
+    }) as Promise<RecordWithId<T>[]>;
+  }
+
+  /**
+   * Aggregate over owner's records: COUNT, SUM, AVG, MIN, MAX, GROUP BY.
+   *
+   * @example
+   *   await users.aggregate(ownerAddress, { count: '*', groupBy: 'role' })
+   *   // => [{ group: 'admin', count: 3 }, { group: 'user', count: 47 }]
+   */
+  async aggregate(
+    ownerAddress  : string,
+    opts          : AggregateOptions,
+    where?        : WhereTuple[],
+    chainLimit?   : bigint,
+  ): Promise<AggregateResult[]> {
+    const records = await this.findMany(ownerAddress, {
+      chainLimit,
+      where,
+    });
+    const rows = records.map((r) => r.data as Record<string, unknown>);
+    return buildQuery(rows).aggregate(opts);
+  }
+
+  // ── Update ──────────────────────────────────────────────────
+
+  /**
+   * Fetch existing data, merge with `patch`, re-encrypt, and update on-chain.
+   */
+  async update(id: bigint, patch: Partial<T>): Promise<ethers.TransactionReceipt> {
+    const current = await this.findUnique(id);
+    if (current === null) throw new Error(`TypedTableClient.update: record ${id} not found`);
+    const merged = { ...current, ...patch } as T;
+    return this.inner.updateRaw(this.key(id), this.encode(merged));
+  }
+
+  /**
+   * Replace a record's data entirely (no merge).
+   * More gas-efficient when you have the full new payload ready.
+   */
+  async replace(id: bigint, data: T): Promise<ethers.TransactionReceipt> {
+    return this.inner.updateRaw(this.key(id), this.encode(data));
+  }
+
+  // ── Delete ──────────────────────────────────────────────────
+
+  /**
+   * Soft-delete a record. The symmetric key is scrubbed for all collaborators.
+   * Only the record owner can call this.
+   */
+  async remove(id: bigint): Promise<ethers.TransactionReceipt> {
+    return this.inner.deleteRecord(this.key(id));
+  }
+
+  // ── Helpers ─────────────────────────────────────────────────
+
+  /** Total number of records ever written by `ownerAddress` (including deleted). */
+  async count(ownerAddress: string): Promise<bigint> {
+    return this.inner.ownerRecordCount(ownerAddress);
+  }
+
+  /** True if a live (non-deleted) record exists for the given id. */
+  async exists(id: bigint): Promise<boolean> {
+    return this.inner.exists(this.key(id));
+  }
+}

package/src/types.ts

@@ -0,0 +1,284 @@
+/**
+ * @file   types.ts
+ * @notice Web3QL v1.1 — extended type system with serialization, validation,
+ *         DEFAULT/NOT NULL enforcement, and codec helpers.
+ *
+ * Every type maps: JS value ↔ JSON-storable "wire" representation.
+ * The chain stores the JSON string; this module handles encode/decode.
+ */
+
+// ─────────────────────────────────────────────────────────────
+//  Field type literal union
+// ─────────────────────────────────────────────────────────────
+
+export type FieldType =
+  | 'INT'       // bigint ↔ decimal string (int256)
+  | 'BIGINT'    // bigint ↔ decimal string (uint256)
+  | 'UINT8'     // number (0–255) ↔ number
+  | 'UINT16'    // number (0–65535) ↔ number
+  | 'UINT32'    // number (0–4294967295) ↔ number
+  | 'UINT64'    // bigint ↔ decimal string
+  | 'TEXT'      // string ↔ string
+  | 'BOOL'      // boolean ↔ boolean
+  | 'FLOAT'     // number ↔ number (stored scaled × 1e6 as integer)
+  | 'ADDRESS'   // string (0x…) ↔ string, lowercased
+  | 'TIMESTAMP' // Date ↔ number (unix ms)
+  | 'DATE'      // Date ↔ number (unix ms of midnight UTC)
+  | 'UUID'      // string (36 chars) ↔ string
+  | 'BYTES32'   // string (0x-prefixed, 66 chars) ↔ string
+  | 'JSON'      // unknown ↔ unknown (validated as parseable JSON)
+  | 'JSONB'     // alias for JSON — schema-less document storage
+  | 'ENUM'      // string (label) ↔ number (index)
+  | 'DECIMAL';  // number ↔ string (exact decimal, no float rounding)
+
+/** Sentinel value stored on-chain when a nullable field has no value. */
+export const NULL_SENTINEL = '__NULL__';
+
+// ─────────────────────────────────────────────────────────────
+//  Field descriptor
+// ─────────────────────────────────────────────────────────────
+
+export interface FieldDescriptor {
+  name       : string;
+  type       : FieldType;
+  primaryKey?: boolean;
+  notNull?   : boolean;
+  /** Static default value OR factory function called on each write */
+  default?   : unknown | (() => unknown);
+  /** ENUM: ordered list of string labels */
+  enumValues?: string[];
+  /** DECIMAL: [totalDigits, decimalPlaces] */
+  precision? : [number, number];
+}
+
+export type SchemaDefinition = FieldDescriptor[];
+
+// ─────────────────────────────────────────────────────────────
+//  Type codecs  (encode: JS → wire,  decode: wire → JS)
+// ─────────────────────────────────────────────────────────────
+
+function encodeInt(v: unknown): number | string {
+  if (typeof v === 'bigint') return v.toString();
+  if (typeof v === 'number') return Math.trunc(v).toString();
+  return String(v);
+}
+function decodeInt(v: unknown): bigint { return BigInt(String(v)); }
+
+function encodeFloat(v: unknown): number {
+  const n = Number(v);
+  if (!isFinite(n)) throw new TypeError(`FLOAT: expected finite number, got ${v}`);
+  // Store as scaled integer to avoid float drift
+  return Math.round(n * 1_000_000);
+}
+function decodeFloat(v: unknown): number { return Number(v) / 1_000_000; }
+
+function encodeTimestamp(v: unknown): number {
+  if (v instanceof Date) return v.getTime();
+  if (typeof v === 'number') return v;
+  if (typeof v === 'string') return new Date(v).getTime();
+  throw new TypeError(`TIMESTAMP: expected Date or number, got ${typeof v}`);
+}
+function decodeTimestamp(v: unknown): Date { return new Date(Number(v)); }
+
+function encodeDate(v: unknown): number {
+  const ms = encodeTimestamp(v);
+  // Truncate to midnight UTC
+  return ms - (ms % 86_400_000);
+}
+function decodeDate(v: unknown): Date {
+  const d = new Date(Number(v));
+  d.setUTCHours(0, 0, 0, 0);
+  return d;
+}
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function encodeUUID(v: unknown): string {
+  const s = String(v).toLowerCase();
+  if (!UUID_RE.test(s)) throw new TypeError(`UUID: invalid format "${s}"`);
+  return s;
+}
+
+const BYTES32_RE = /^0x[0-9a-f]{64}$/i;
+function encodeBytes32(v: unknown): string {
+  const s = String(v).toLowerCase();
+  if (!BYTES32_RE.test(s)) throw new TypeError(`BYTES32: expected 0x-prefixed 64-hex-char string, got "${s}"`);
+  return s;
+}
+
+const ADDRESS_RE = /^0x[0-9a-f]{40}$/i;
+function encodeAddress(v: unknown): string {
+  const s = String(v).toLowerCase();
+  if (!ADDRESS_RE.test(s)) throw new TypeError(`ADDRESS: invalid EVM address "${s}"`);
+  return s;
+}
+
+function encodeUint(bits: 8 | 16 | 32, v: unknown): number {
+  const n = Number(v);
+  const max = bits === 8 ? 255 : bits === 16 ? 65535 : 4294967295;
+  if (!Number.isInteger(n) || n < 0 || n > max) {
+    throw new RangeError(`UINT${bits}: value ${n} out of range [0, ${max}]`);
+  }
+  return n;
+}
+
+function encodeUint64(v: unknown): string {
+  const n = BigInt(String(v));
+  if (n < 0n) throw new RangeError(`UINT64: value must be non-negative`);
+  return n.toString();
+}
+
+function encodeJSON(v: unknown): unknown {
+  // Validate it round-trips cleanly
+  JSON.parse(JSON.stringify(v));
+  return v;
+}
+
+function encodeEnum(field: FieldDescriptor, v: unknown): number {
+  const labels = field.enumValues ?? [];
+  if (typeof v === 'number') {
+    if (v < 0 || v >= labels.length) throw new RangeError(`ENUM: index ${v} out of range [0,${labels.length})`);
+    return v;
+  }
+  const idx = labels.indexOf(String(v));
+  if (idx === -1) throw new TypeError(`ENUM: "${v}" not in [${labels.join(', ')}]`);
+  return idx;
+}
+function decodeEnum(field: FieldDescriptor, v: unknown): string {
+  const labels = field.enumValues ?? [];
+  const idx    = Number(v);
+  return labels[idx] ?? String(v);
+}
+
+function encodeDecimal(field: FieldDescriptor, v: unknown): string {
+  const n = Number(v);
+  if (!isFinite(n)) throw new TypeError(`DECIMAL: expected finite number, got ${v}`);
+  const scale = field.precision?.[1] ?? 2;
+  return n.toFixed(scale);
+}
+function decodeDecimal(v: unknown): number { return parseFloat(String(v)); }
+
+// ─────────────────────────────────────────────────────────────
+//  Public encode / decode helpers
+// ─────────────────────────────────────────────────────────────
+
+/** Encode a JS value → wire format (to be JSON-stringified and stored). */
+export function encodeFieldValue(field: FieldDescriptor, value: unknown): unknown {
+  switch (field.type) {
+    case 'INT':
+    case 'BIGINT':    return encodeInt(value);
+    case 'UINT8':     return encodeUint(8, value);
+    case 'UINT16':    return encodeUint(16, value);
+    case 'UINT32':    return encodeUint(32, value);
+    case 'UINT64':    return encodeUint64(value);
+    case 'TEXT':      return String(value);
+    case 'BOOL':      return Boolean(value);
+    case 'FLOAT':     return encodeFloat(value);
+    case 'ADDRESS':   return encodeAddress(value);
+    case 'TIMESTAMP': return encodeTimestamp(value);
+    case 'DATE':      return encodeDate(value);
+    case 'UUID':      return encodeUUID(value);
+    case 'BYTES32':   return encodeBytes32(value);
+    case 'JSON':
+    case 'JSONB':     return encodeJSON(value);
+    case 'ENUM':      return encodeEnum(field, value);
+    case 'DECIMAL':   return encodeDecimal(field, value);
+  }
+}
+
+/** Decode a wire-format value → typed JS value. */
+export function decodeFieldValue(field: FieldDescriptor, value: unknown): unknown {
+  if (value === NULL_SENTINEL) return null;
+  if (value === null || value === undefined) return value;
+  switch (field.type) {
+    case 'INT':
+    case 'BIGINT':    return decodeInt(value);
+    case 'UINT64':    return BigInt(String(value));
+    case 'UINT8':
+    case 'UINT16':
+    case 'UINT32':    return Number(value);
+    case 'TEXT':
+    case 'UUID':
+    case 'BYTES32':
+    case 'ADDRESS':   return String(value);
+    case 'BOOL':      return Boolean(value);
+    case 'FLOAT':     return decodeFloat(value);
+    case 'TIMESTAMP': return decodeTimestamp(value);
+    case 'DATE':      return decodeDate(value);
+    case 'JSON':
+    case 'JSONB':     return value;
+    case 'ENUM':      return decodeEnum(field, value);
+    case 'DECIMAL':   return decodeDecimal(value);
+  }
+}
+
+// ─────────────────────────────────────────────────────────────
+//  Row-level validation — NOT NULL + DEFAULT + type coerce
+// ─────────────────────────────────────────────────────────────
+
+/**
+ * Validate and normalise a plain JS object before writing to the chain.
+ *
+ * • Applies DEFAULT values for missing fields
+ * • Enforces NOT NULL for fields without a default
+ * • Encodes each field to its wire representation
+ *
+ * @param schema  SchemaDefinition for this table
+ * @param row     Raw user input object
+ * @returns       Wire-ready object (to be JSON.stringify'd and encrypted)
+ */
+export function validateAndEncode(
+  schema: SchemaDefinition,
+  row   : Record<string, unknown>,
+): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+
+  for (const field of schema) {
+    let value = row[field.name];
+
+    // Apply default if value is absent
+    if (value === undefined || value === null) {
+      if (field.default !== undefined) {
+        value = typeof field.default === 'function'
+          ? (field.default as () => unknown)()
+          : field.default;
+      }
+    }
+
+    // NOT NULL enforcement
+    if ((value === undefined || value === null) && field.notNull) {
+      throw new TypeError(
+        `Field "${field.name}" is NOT NULL but no value or default was provided.`
+      );
+    }
+
+    // Skip truly absent optional fields (store as NULL_SENTINEL for type safety)
+    if (value === undefined || value === null) {
+      out[field.name] = NULL_SENTINEL;
+      continue;
+    }
+
+    out[field.name] = encodeFieldValue(field, value);
+  }
+
+  return out;
+}
+
+/**
+ * Decode a wire-format JSON object back to typed JS values.
+ *
+ * @param schema  SchemaDefinition for this table
+ * @param wire    Object from JSON.parse(plaintext)
+ */
+export function decodeRow(
+  schema: SchemaDefinition,
+  wire  : Record<string, unknown>,
+): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  const byName = new Map(schema.map((f) => [f.name, f]));
+
+  for (const [key, value] of Object.entries(wire)) {
+    const field = byName.get(key);
+    out[key] = field ? decodeFieldValue(field, value) : value;
+  }
+  return out;
+}

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "target"                    : "ES2022",
+    "module"                    : "Node16",
+    "moduleResolution"          : "Node16",
+    "lib"                       : ["ES2022"],
+    "outDir"                    : "dist",
+    "rootDir"                   : ".",
+    "declaration"                : true,
+    "declarationMap"             : true,
+    "sourceMap"                  : true,
+    "esModuleInterop"            : true,
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule"          : true,
+    "strict"                     : true,
+    "noUncheckedIndexedAccess"   : true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck"               : true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}