cl-orm 0.1.0 → 0.1.1

package/lib/drivers/_utils.d.ts

@@ -0,0 +1,4 @@
+import type { Meta } from '../types.js';
+export declare const returnsRows: (sql: string) => boolean;
+export declare const prepare: (db: D1Database, sql: string, params: unknown[]) => D1PreparedStatement;
+export declare const setMeta: (cursor: SqlStorageCursor<Record<string, SqlStorageValue>>) => Meta;

package/lib/drivers/_utils.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setMeta = exports.prepare = exports.returnsRows = void 0;
+const returnsRows = (sql) => {
+    const trimmed = sql.trimStart().toUpperCase();
+    return (trimmed.indexOf('SELECT') === 0 ||
+        trimmed.indexOf('WITH') === 0 ||
+        trimmed.indexOf('PRAGMA') === 0 ||
+        trimmed.indexOf('RETURNING') !== -1);
+};
+exports.returnsRows = returnsRows;
+const prepare = (db, sql, params) => params.length > 0 ? db.prepare(sql).bind(...params) : db.prepare(sql);
+exports.prepare = prepare;
+const setMeta = (cursor) => ({
+    duration: 0,
+    size_after: 0,
+    rows_read: cursor.rowsRead,
+    rows_written: cursor.rowsWritten,
+    last_row_id: 0,
+    changed_db: cursor.rowsWritten > 0,
+    changes: cursor.rowsWritten,
+});
+exports.setMeta = setMeta;

package/lib/drivers/d1.d.ts

@@ -0,0 +1,2 @@
+import type { Connection } from '../types.js';
+export declare const useD1: (db: D1Database) => Connection;

package/lib/drivers/d1.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useD1 = void 0;
+const delete_js_1 = require("../queries/delete.js");
+const insert_js_1 = require("../queries/insert.js");
+const select_js_1 = require("../queries/select.js");
+const update_js_1 = require("../queries/update.js");
+const _utils_js_1 = require("./_utils.js");
+const useD1 = (db) => {
+    const query = async (sql, values) => {
+        const statement = values
+            ? db.prepare(sql).bind(...values)
+            : db.prepare(sql);
+        if ((0, _utils_js_1.returnsRows)(sql)) {
+            const { results, meta } = await statement.all();
+            return { rows: results, meta: meta };
+        }
+        const { meta } = await statement.run();
+        return { rows: [], meta: meta };
+    };
+    const select = async (options) => {
+        const { sql, params } = (0, select_js_1.buildSelect)(options);
+        const statement = (0, _utils_js_1.prepare)(db, sql, params);
+        if (options.limit === 1)
+            return statement.first();
+        const { results } = await statement.all();
+        return results;
+    };
+    const insert = async (options) => {
+        const { sql, params } = (0, insert_js_1.buildInsert)(options);
+        const { meta } = await query(sql, params);
+        return meta;
+    };
+    const update = async (options) => {
+        const { sql, params } = (0, update_js_1.buildUpdate)(options);
+        const statement = (0, _utils_js_1.prepare)(db, sql, params);
+        const { meta } = await statement.run();
+        return meta;
+    };
+    const del = async (options) => {
+        const { sql, params } = (0, delete_js_1.buildDelete)(options);
+        const statement = (0, _utils_js_1.prepare)(db, sql, params);
+        const { meta } = await statement.run();
+        return meta;
+    };
+    return { query, select, insert, update, delete: del };
+};
+exports.useD1 = useD1;

package/lib/drivers/do.d.ts

@@ -0,0 +1,2 @@
+import type { Connection } from '../types.js';
+export declare const useDO: (sql: SqlStorage) => Connection;

package/lib/drivers/do.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDO = void 0;
+const delete_js_1 = require("../queries/delete.js");
+const insert_js_1 = require("../queries/insert.js");
+const select_js_1 = require("../queries/select.js");
+const update_js_1 = require("../queries/update.js");
+const _utils_js_1 = require("./_utils.js");
+const useDO = (sql) => {
+    const exec = (query, values) => (values ? sql.exec(query, ...values) : sql.exec(query));
+    const query = async (queryStr, values) => {
+        const cursor = exec(queryStr, values);
+        if ((0, _utils_js_1.returnsRows)(queryStr)) {
+            const rows = cursor.toArray();
+            return { rows, meta: (0, _utils_js_1.setMeta)(cursor) };
+        }
+        return { rows: [], meta: (0, _utils_js_1.setMeta)(cursor) };
+    };
+    const select = async (options) => {
+        const built = (0, select_js_1.buildSelect)(options);
+        const cursor = exec(built.sql, built.params.length > 0 ? built.params : undefined);
+        if (options.limit === 1) {
+            const rows = cursor.toArray();
+            return rows[0] ?? null;
+        }
+        return cursor.toArray();
+    };
+    const insert = async (options) => {
+        const built = (0, insert_js_1.buildInsert)(options);
+        const cursor = exec(built.sql, built.params);
+        return (0, _utils_js_1.setMeta)(cursor);
+    };
+    const update = async (options) => {
+        const built = (0, update_js_1.buildUpdate)(options);
+        const cursor = exec(built.sql, built.params.length > 0 ? built.params : undefined);
+        return (0, _utils_js_1.setMeta)(cursor);
+    };
+    const del = async (options) => {
+        const built = (0, delete_js_1.buildDelete)(options);
+        const cursor = exec(built.sql, built.params.length > 0 ? built.params : undefined);
+        return (0, _utils_js_1.setMeta)(cursor);
+    };
+    return { query, select, insert, update, delete: del };
+};
+exports.useDO = useDO;

package/{src/index.ts → lib/index.d.ts}

@@ -1,13 +1,4 @@
 export { useD1 } from './drivers/d1.js';
 export { useDO } from './drivers/do.js';
 export { OP } from './queries/where/operators.js';
-
-export type {
-  QueryResult,
-  Connection,
-  Meta,
-  Condition,
-  Param,
-  WhereClause,
-  WhereItem,
-} from './types.js';
+export type { QueryResult, Connection, Meta, Condition, Param, WhereClause, WhereItem, } from './types.js';

package/lib/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OP = exports.useDO = exports.useD1 = void 0;
+var d1_js_1 = require("./drivers/d1.js");
+Object.defineProperty(exports, "useD1", { enumerable: true, get: function () { return d1_js_1.useD1; } });
+var do_js_1 = require("./drivers/do.js");
+Object.defineProperty(exports, "useDO", { enumerable: true, get: function () { return do_js_1.useDO; } });
+var operators_js_1 = require("./queries/where/operators.js");
+Object.defineProperty(exports, "OP", { enumerable: true, get: function () { return operators_js_1.OP; } });

package/lib/queries/_utils.d.ts

@@ -0,0 +1 @@
+export declare const quoteIdentifier: (name: string) => string;

package/lib/queries/_utils.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quoteIdentifier = void 0;
+const quoteIdentifier = (name) => {
+    if (name.includes('.')) {
+        return name
+            .split('.')
+            .map((part) => `\`${part}\``)
+            .join('.');
+    }
+    return `\`${name}\``;
+};
+exports.quoteIdentifier = quoteIdentifier;

package/lib/queries/delete.d.ts

@@ -0,0 +1,5 @@
+import type { DeleteOptions } from '../types.js';
+export declare const buildDelete: (options: DeleteOptions) => {
+    sql: string;
+    params: unknown[];
+};

package/lib/queries/delete.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildDelete = void 0;
+const _utils_js_1 = require("./_utils.js");
+const where_js_1 = require("./where/where.js");
+const buildDelete = (options) => {
+    const parts = ['DELETE FROM', (0, _utils_js_1.quoteIdentifier)(options.table)];
+    const params = [];
+    if (options.where) {
+        const where = (0, where_js_1.buildWhere)(options.where);
+        parts.push('WHERE', where.sql);
+        params.push(...where.params);
+    }
+    if (options.limit !== undefined) {
+        parts.push('LIMIT ?');
+        params.push(options.limit);
+    }
+    if (options.params)
+        params.unshift(...options.params);
+    return { sql: parts.join(' '), params };
+};
+exports.buildDelete = buildDelete;

package/lib/queries/insert.d.ts

@@ -0,0 +1,5 @@
+import type { InsertOptions } from '../types.js';
+export declare const buildInsert: (options: InsertOptions) => {
+    sql: string;
+    params: unknown[];
+};

package/lib/queries/insert.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildInsert = void 0;
+const _utils_js_1 = require("./_utils.js");
+const buildInsert = (options) => {
+    const rows = Array.isArray(options.values)
+        ? options.values
+        : [options.values];
+    const columns = Object.keys(rows[0]);
+    const columnsSql = columns.map(_utils_js_1.quoteIdentifier).join(', ');
+    const placeholders = `(${columns.map(() => '?').join(', ')})`;
+    const valuesSql = rows.map(() => placeholders).join(', ');
+    const params = rows.flatMap((row) => columns.map((col) => row[col]));
+    return {
+        sql: `INSERT INTO ${(0, _utils_js_1.quoteIdentifier)(options.table)} (${columnsSql}) VALUES ${valuesSql}`,
+        params,
+    };
+};
+exports.buildInsert = buildInsert;

package/lib/queries/select.d.ts

@@ -0,0 +1,5 @@
+import type { SelectOptions } from '../types.js';
+export declare const buildSelect: (options: SelectOptions) => {
+    sql: string;
+    params: unknown[];
+};

package/lib/queries/select.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSelect = void 0;
+const _utils_js_1 = require("./_utils.js");
+const where_js_1 = require("./where/where.js");
+const buildColumns = (columns) => {
+    if (!columns)
+        return '*';
+    if (typeof columns === 'string')
+        return columns;
+    return columns.map(_utils_js_1.quoteIdentifier).join(', ');
+};
+const buildJoin = (join) => {
+    const type = join.outer
+        ? `${join.type.toUpperCase()} OUTER`
+        : join.type.toUpperCase();
+    return `${type} JOIN ${(0, _utils_js_1.quoteIdentifier)(join.table)} ON ${(0, _utils_js_1.quoteIdentifier)(join.on.a)} = ${(0, _utils_js_1.quoteIdentifier)(join.on.b)}`;
+};
+const buildSelect = (options) => {
+    const parts = ['SELECT'];
+    const params = [];
+    if (options.distinct)
+        parts.push('DISTINCT');
+    parts.push(buildColumns(options.columns));
+    parts.push('FROM', (0, _utils_js_1.quoteIdentifier)(options.table));
+    if (options.join) {
+        const joins = Array.isArray(options.join) ? options.join : [options.join];
+        for (const join of joins) {
+            parts.push(buildJoin(join));
+        }
+    }
+    if (options.where) {
+        const where = (0, where_js_1.buildWhere)(options.where);
+        parts.push('WHERE', where.sql);
+        params.push(...where.params);
+    }
+    if (options.groupBy)
+        parts.push('GROUP BY', (0, _utils_js_1.quoteIdentifier)(options.groupBy));
+    if (options.orderBy) {
+        const [column, direction = 'ASC'] = options.orderBy;
+        parts.push('ORDER BY', (0, _utils_js_1.quoteIdentifier)(column), direction);
+    }
+    if (options.limit !== undefined) {
+        parts.push('LIMIT ?');
+        params.push(options.limit);
+    }
+    if (options.offset !== undefined) {
+        parts.push('OFFSET ?');
+        params.push(options.offset);
+    }
+    if (options.params)
+        params.unshift(...options.params);
+    return { sql: parts.join(' '), params };
+};
+exports.buildSelect = buildSelect;

package/lib/queries/update.d.ts

@@ -0,0 +1,5 @@
+import type { UpdateOptions } from '../types.js';
+export declare const buildUpdate: (options: UpdateOptions) => {
+    sql: string;
+    params: unknown[];
+};

package/lib/queries/update.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildUpdate = void 0;
+const _utils_js_1 = require("./_utils.js");
+const where_js_1 = require("./where/where.js");
+const buildUpdate = (options) => {
+    const columns = Object.keys(options.set);
+    const setSql = columns.map((col) => `${(0, _utils_js_1.quoteIdentifier)(col)} = ?`).join(', ');
+    const params = columns.map((col) => options.set[col]);
+    const parts = [
+        'UPDATE',
+        (0, _utils_js_1.quoteIdentifier)(options.table),
+        'SET',
+        setSql,
+    ];
+    if (options.where) {
+        const where = (0, where_js_1.buildWhere)(options.where);
+        parts.push('WHERE', where.sql);
+        params.push(...where.params);
+    }
+    if (options.params)
+        params.push(...options.params);
+    return { sql: parts.join(' '), params };
+};
+exports.buildUpdate = buildUpdate;

package/lib/queries/where/operators.d.ts

@@ -0,0 +1,23 @@
+import type { Condition, Param } from '../../types.js';
+export declare const OP: {
+    eq: (column: string, param: Param) => Condition;
+    ne: (column: string, param: Param) => Condition;
+    gt: (column: string, param: Param) => Condition;
+    lt: (column: string, param: Param) => Condition;
+    gte: (column: string, param: Param) => Condition;
+    lte: (column: string, param: Param) => Condition;
+    like: (column: string, param: Param) => Condition;
+    notLike: (column: string, param: Param) => Condition;
+    isNull: (column: string) => Condition;
+    isNotNull: (column: string) => Condition;
+    in: {
+        (column: string, params: Param[]): Condition;
+        (column: string, subquery: string, params: Param[]): Condition;
+    };
+    notIn: {
+        (column: string, params: Param[]): Condition;
+        (column: string, subquery: string, params: Param[]): Condition;
+    };
+    between: (column: string, params: [Param, Param]) => Condition;
+    notBetween: (column: string, params: [Param, Param]) => Condition;
+};

package/lib/queries/where/operators.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OP = void 0;
+const _utils_js_1 = require("../_utils.js");
+const comparison = (column, operator, param) => ({
+    condition: `${(0, _utils_js_1.quoteIdentifier)(column)} ${operator} ?`,
+    params: [param],
+});
+exports.OP = {
+    eq: (column, param) => comparison(column, '=', param),
+    ne: (column, param) => comparison(column, '!=', param),
+    gt: (column, param) => comparison(column, '>', param),
+    lt: (column, param) => comparison(column, '<', param),
+    gte: (column, param) => comparison(column, '>=', param),
+    lte: (column, param) => comparison(column, '<=', param),
+    like: (column, param) => comparison(column, 'LIKE', param),
+    notLike: (column, param) => comparison(column, 'NOT LIKE', param),
+    isNull: (column) => ({
+        condition: `${(0, _utils_js_1.quoteIdentifier)(column)} IS NULL`,
+        params: [],
+    }),
+    isNotNull: (column) => ({
+        condition: `${(0, _utils_js_1.quoteIdentifier)(column)} IS NOT NULL`,
+        params: [],
+    }),
+    in: ((column, valuesOrSubquery, subqueryParams) => {
+        if (typeof valuesOrSubquery === 'string') {
+            return {
+                condition: `${(0, _utils_js_1.quoteIdentifier)(column)} IN (${valuesOrSubquery})`,
+                params: subqueryParams ?? [],
+            };
+        }
+        const placeholders = valuesOrSubquery.map(() => '?').join(', ');
+        return {
+            condition: `${(0, _utils_js_1.quoteIdentifier)(column)} IN (${placeholders})`,
+            params: valuesOrSubquery,
+        };
+    }),
+    notIn: ((column, valuesOrSubquery, subqueryParams) => {
+        if (typeof valuesOrSubquery === 'string') {
+            return {
+                condition: `${(0, _utils_js_1.quoteIdentifier)(column)} NOT IN (${valuesOrSubquery})`,
+                params: subqueryParams ?? [],
+            };
+        }
+        const placeholders = valuesOrSubquery.map(() => '?').join(', ');
+        return {
+            condition: `${(0, _utils_js_1.quoteIdentifier)(column)} NOT IN (${placeholders})`,
+            params: valuesOrSubquery,
+        };
+    }),
+    between: (column, params) => ({
+        condition: `${(0, _utils_js_1.quoteIdentifier)(column)} BETWEEN ? AND ?`,
+        params,
+    }),
+    notBetween: (column, params) => ({
+        condition: `${(0, _utils_js_1.quoteIdentifier)(column)} NOT BETWEEN ? AND ?`,
+        params,
+    }),
+};

package/lib/queries/where/where.d.ts

@@ -0,0 +1,5 @@
+import type { Param, WhereClause } from '../../types.js';
+export declare const buildWhere: (where: WhereClause) => {
+    sql: string;
+    params: Param[];
+};

package/lib/queries/where/where.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildWhere = void 0;
+const isConnector = (value) => typeof value === 'string' && ['AND', 'OR', 'XOR', 'NOT'].includes(value);
+const isCondition = (value) => typeof value === 'object' && !Array.isArray(value) && 'condition' in value;
+const processItems = (items) => {
+    const parts = [];
+    const params = [];
+    for (const item of items) {
+        if (isConnector(item)) {
+            parts.push(item);
+            continue;
+        }
+        if (isCondition(item)) {
+            parts.push(item.condition);
+            params.push(...item.params);
+            continue;
+        }
+        if (Array.isArray(item)) {
+            const group = processItems(item);
+            parts.push(`(${group.sql})`);
+            params.push(...group.params);
+        }
+    }
+    return { sql: parts.join(' '), params };
+};
+const buildWhere = (where) => {
+    if (typeof where === 'string')
+        return { sql: where, params: [] };
+    if (isCondition(where))
+        return { sql: where.condition, params: [...where.params] };
+    return processItems(where);
+};
+exports.buildWhere = buildWhere;

package/lib/types.d.ts

@@ -0,0 +1,64 @@
+export type Param = string | number | boolean | null;
+export type Condition = {
+    condition: string;
+    params: Param[];
+};
+export type Connector = 'AND' | 'OR' | 'XOR' | 'NOT';
+export type WhereItem = Condition | Connector | WhereItem[];
+export type WhereClause = string | Condition | WhereItem[];
+type Values = Record<string, unknown>;
+export type InsertOptions = {
+    table: string;
+    values: Values | Values[];
+};
+export type JoinOptions = {
+    type: 'left' | 'right' | 'inner' | 'cross';
+    table: string;
+    on: {
+        a: string;
+        b: string;
+    };
+    outer?: boolean;
+};
+export type SelectOptions = {
+    distinct?: boolean;
+    columns?: string | string[];
+    table: string;
+    join?: JoinOptions | JoinOptions[];
+    where?: WhereClause;
+    limit?: number;
+    offset?: number;
+    groupBy?: string;
+    orderBy?: [string] | [string, 'ASC' | 'DESC'];
+    params?: unknown[];
+};
+export type UpdateOptions = {
+    table: string;
+    set: Record<string, unknown>;
+    where?: WhereClause;
+    params?: unknown[];
+};
+export type DeleteOptions = {
+    table: string;
+    where?: WhereClause;
+    limit?: number;
+    params?: unknown[];
+};
+export type Meta = D1Meta & Record<string, unknown>;
+export type QueryResult<T> = {
+    rows: T[];
+    meta: Meta;
+};
+export type Connection = {
+    query: <T = Record<string, unknown>>(sql: string, values?: unknown[]) => Promise<QueryResult<T>>;
+    select: {
+        <T = Record<string, unknown>>(options: SelectOptions & {
+            limit: 1;
+        }): Promise<T | null>;
+        <T = Record<string, unknown>>(options: SelectOptions): Promise<T[]>;
+    };
+    insert: (options: InsertOptions) => Promise<Meta>;
+    update: (options: UpdateOptions) => Promise<Meta>;
+    delete: (options: DeleteOptions) => Promise<Meta>;
+};
+export {};

package/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,7 +1,17 @@
 {
   "name": "cl-orm",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "A lightweight ORM for Cloudflare Workers (D1 and Durable Objects), designed to be intuitive, productive and focused on essential functionality",
+  "homepage": "https://wellwelwel.github.io/cl-orm/docs/",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wellwelwel/cl-orm.git"
+  },
+  "author": "https://github.com/wellwelwel",
+  "bugs": {
+    "url": "https://github.com/wellwelwel/cl-orm/issues"
+  },
   "scripts": {
     "dev:d1": "wrangler dev --config test/__fixtures__/d1/wrangler.jsonc --port 8787 --inspector-port 9229",
     "dev:do": "wrangler dev --config test/__fixtures__/do/wrangler.jsonc --port 8788 --inspector-port 9230",
@@ -26,5 +36,20 @@
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "wrangler": "^4.61.1"
-  }
+  },
+  "files": [
+    "lib"
+  ],
+  "keywords": [
+    "cloudflare",
+    "workers",
+    "orm",
+    "durable objects",
+    "durable-objects",
+    "d1",
+    "database",
+    "sqlite",
+    "prisma",
+    "drizzle"
+  ]
 }

package/.editorconfig

@@ -1,12 +0,0 @@
-# http://editorconfig.org
-root = true
-
-[*]
-indent_style = tab
-end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = true
-insert_final_newline = true
-
-[*.yml]
-indent_style = space

package/.gitattributes

@@ -1 +0,0 @@
-website/** linguist-documentation

package/.prettierignore

@@ -1,3 +0,0 @@
-/lib
-/CHANGELOG.md
-/website

package/.prettierrc

@@ -1,34 +0,0 @@
-{
-  "printWidth": 80,
-  "tabWidth": 2,
-  "useTabs": false,
-  "semi": true,
-  "singleQuote": true,
-  "quoteProps": "as-needed",
-  "jsxSingleQuote": true,
-  "trailingComma": "es5",
-  "bracketSpacing": true,
-  "bracketSameLine": false,
-  "arrowParens": "always",
-  "proseWrap": "preserve",
-  "endOfLine": "auto",
-  "embeddedLanguageFormatting": "auto",
-  "singleAttributePerLine": false,
-  "plugins": ["@ianvs/prettier-plugin-sort-imports"],
-  "importOrder": [
-    "<TYPES>^(node:)",
-    "<TYPES>",
-    "<TYPES>^[.]",
-    "<BUILTIN_MODULES>",
-    "<THIRD_PARTY_MODULES>",
-    "^[.]"
-  ],
-  "overrides": [
-    {
-      "files": "*.jsonc",
-      "options": {
-        "trailingComma": "none"
-      }
-    }
-  ]
-}

package/.vscode/settings.json

@@ -1,14 +0,0 @@
-{
-  "editor.trimAutoWhitespace": true,
-  "editor.indentSize": 2,
-  "editor.tabSize": 2,
-  "editor.formatOnSave": true,
-  "files.trimTrailingWhitespace": true,
-  "editor.defaultFormatter": "esbenp.prettier-vscode",
-  "editor.codeActionsOnSave": {
-    "source.fixAll": "explicit"
-  },
-  "[markdown]": {
-    "files.trimTrailingWhitespace": false
-  }
-}

package/mcr.config.ts

@@ -1,12 +0,0 @@
-import type { CoverageReportOptions } from 'monocart-coverage-reports';
-
-const coverageOptions: CoverageReportOptions = {
-  reports: ['v8', 'console-details', 'codecov'],
-  entryFilter: {
-    '**/node_modules/**': false,
-    '**/test/**': false,
-    '**/src/**': true,
-  },
-};
-
-export default coverageOptions;