graphile-test 0.1.1 → 2.0.1

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2019 Dan Lynch <pyramation@gmail.com>
+Copyright (c) 2024 Dan Lynch <pyramation@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,51 +1,53 @@
-# graphile-test [![Build Status](https://travis-ci.org/pyramation/graphile-test.svg?branch=master)](https://travis-ci.org/pyramation/graphile-test)
+# graphile-test
+
+<p align="center" width="100%">
+  <img height="250" src="https://github.com/user-attachments/assets/d0456af5-b6e9-422e-a45d-2574d5be490f" />
+</p>
+
+<p align="center" width="100%">
+  <a href="https://github.com/launchql/launchql-2.0/actions/workflows/run-tests.yaml">
+    <img height="20" src="https://github.com/launchql/launchql-2.0/actions/workflows/run-tests.yaml/badge.svg" />
+  </a>
+  <a href="https://github.com/launchql/launchql-2.0/blob/main/LICENSE-MIT">
+    <img height="20" src="https://img.shields.io/badge/license-MIT-blue.svg"/>
+  </a>
+  <a href="https://www.npmjs.com/package/graphile-test">
+    <img height="20" src="https://img.shields.io/github/package-json/v/launchql/launchql-2.0?filename=packages%2Fgraphile-test%2Fpackage.json"/>
+  </a>
+</p>
+
+## Install
 
 ```sh
-npm install graphile-test 
+npm install graphile-test
 ```
 
-# how to use
+---
 
-## environment vars
+## How to Use
 
-make sure env vars are set:
-
-```
-PGUSER
-PGPASSWORD
-PGHOST
-PGPORT
-PGDATABASE
-SCHEMA
-```
-
-## postgres users
+### 1. Create Required Postgres Role
 
 ```sql
 CREATE ROLE authenticated;
 ```
 
-## write test
-
-Then in a test:
+---
 
-```js
-import { GraphQLTest, env, snapshot } from 'graphile-test';
-import { MyGraphQuery } from '../utils/queries';
+### 2. Write a Test
 
-const { SCHEMA } = env;
+```ts
+import { GraphQLTest, snapshot } from 'graphile-test';
+import { MyGraphQLQuery } from '../src/queries';
 
-const getDbString = () =>
-  `postgres://${env.PGUSER}:${env.PGPASSWORD}@${env.PGHOST}:${env.PGPORT}/${env.PGDATABASE}`;
+const dbname = 'graphile_test_db';
+const schemas = ['app_public'];
 
-const { setup, teardown, graphQL } = GraphQLTest(
-  {
-    appendPlugins: [],
-    schema: SCHEMA,
-    graphqlRoute: '/graphql'
-  },
-  getDbString()
-);
+const { setup, teardown, graphQL } = GraphQLTest({
+  dbname,
+  schemas,
+  authRole: 'postgres',
+});
 
 beforeAll(async () => {
   await setup();
@@ -54,18 +56,43 @@ afterAll(async () => {
   await teardown();
 });
 
-it('it works!', async () => {
+it('query', async () => {
   await graphQL(async query => {
-    const data = await query(MyGraphQuery);
+    const data = await query(MyGraphQLQuery);
     expect(snapshot(data)).toMatchSnapshot();
   });
 });
+```
+
+---
+
+## Testing Setup
+
+Before running tests, prepare your database:
 
+```sh
+createdb graphile_test_db
+psql -f sql/test.sql graphile_test_db
 ```
 
-## testing
+---
+
+## Environment Variables
+
+You can override the default Postgres connection settings by setting the following environment variables:
 
 ```sh
-createdb test_database
-psql test_database < sql/test.sql
-```
+export PGUSER=your_pg_user
+export PGHOST=your_pg_host
+export PGPORT=your_pg_port
+```
+
+Once set, these will be automatically picked up by `graphile-test` when establishing connections.
+
+---
+
+## Disclaimer
+
+AS DESCRIBED IN THE LICENSES, THE SOFTWARE IS PROVIDED “AS IS”, AT YOUR OWN RISK, AND WITHOUT WARRANTIES OF ANY KIND.
+
+No developer or entity involved in creating this software will be liable for any claims or damages whatsoever associated with your use, inability to use, or your interaction with other users of the code, including any direct, indirect, incidental, special, exemplary, punitive or consequential damages, or loss of profits, cryptocurrencies, tokens, or anything else of value.

package/clean.d.ts

@@ -0,0 +1,9 @@
+type AnyObject = Record<string, any>;
+export declare const pruneDates: (row: AnyObject) => AnyObject;
+export declare const pruneIds: (row: AnyObject) => AnyObject;
+export declare const pruneIdArrays: (row: AnyObject) => AnyObject;
+export declare const pruneUUIDs: (row: AnyObject) => AnyObject;
+export declare const pruneHashes: (row: AnyObject) => AnyObject;
+export declare const prune: (obj: AnyObject) => AnyObject;
+export declare const snapshot: (obj: unknown) => unknown;
+export {};

package/clean.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.snapshot = exports.prune = exports.pruneHashes = exports.pruneUUIDs = exports.pruneIdArrays = exports.pruneIds = exports.pruneDates = void 0;
+const uuidRegexp = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const idReplacement = (v) => (!v ? v : '[ID]');
+function mapValues(obj, fn) {
+    return Object.entries(obj).reduce((acc, [key, value]) => {
+        acc[key] = fn(value, key);
+        return acc;
+    }, {});
+}
+const pruneDates = (row) => mapValues(row, (v, k) => {
+    if (!v) {
+        return v;
+    }
+    if (v instanceof Date) {
+        return '[DATE]';
+    }
+    else if (typeof v === 'string' &&
+        /(_at|At)$/.test(k) &&
+        /^20[0-9]{2}-[0-9]{2}-[0-9]{2}/.test(v)) {
+        return '[DATE]';
+    }
+    return v;
+});
+exports.pruneDates = pruneDates;
+const pruneIds = (row) => mapValues(row, (v, k) => (k === 'id' || (typeof k === 'string' && k.endsWith('_id'))) &&
+    (typeof v === 'string' || typeof v === 'number')
+    ? idReplacement(v)
+    : v);
+exports.pruneIds = pruneIds;
+const pruneIdArrays = (row) => mapValues(row, (v, k) => typeof k === 'string' && k.endsWith('_ids') && Array.isArray(v)
+    ? `[UUIDs-${v.length}]`
+    : v);
+exports.pruneIdArrays = pruneIdArrays;
+const pruneUUIDs = (row) => mapValues(row, (v, k) => {
+    if (typeof v !== 'string') {
+        return v;
+    }
+    if (['uuid', 'queue_name'].includes(k) && uuidRegexp.test(v)) {
+        return '[UUID]';
+    }
+    if (k === 'gravatar' && /^[0-9a-f]{32}$/i.test(v)) {
+        return '[gUUID]';
+    }
+    return v;
+});
+exports.pruneUUIDs = pruneUUIDs;
+const pruneHashes = (row) => mapValues(row, (v, k) => typeof k === 'string' &&
+    k.endsWith('_hash') &&
+    typeof v === 'string' &&
+    v.startsWith('$')
+    ? '[hash]'
+    : v);
+exports.pruneHashes = pruneHashes;
+const prune = (obj) => (0, exports.pruneHashes)((0, exports.pruneUUIDs)((0, exports.pruneIds)((0, exports.pruneIdArrays)((0, exports.pruneDates)(obj)))));
+exports.prune = prune;
+const snapshot = (obj) => {
+    if (Array.isArray(obj)) {
+        return obj.map(exports.snapshot);
+    }
+    else if (obj && typeof obj === 'object') {
+        return mapValues((0, exports.prune)(obj), exports.snapshot);
+    }
+    return obj;
+};
+exports.snapshot = snapshot;

package/esm/clean.js

@@ -0,0 +1,57 @@
+const uuidRegexp = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const idReplacement = (v) => (!v ? v : '[ID]');
+function mapValues(obj, fn) {
+    return Object.entries(obj).reduce((acc, [key, value]) => {
+        acc[key] = fn(value, key);
+        return acc;
+    }, {});
+}
+export const pruneDates = (row) => mapValues(row, (v, k) => {
+    if (!v) {
+        return v;
+    }
+    if (v instanceof Date) {
+        return '[DATE]';
+    }
+    else if (typeof v === 'string' &&
+        /(_at|At)$/.test(k) &&
+        /^20[0-9]{2}-[0-9]{2}-[0-9]{2}/.test(v)) {
+        return '[DATE]';
+    }
+    return v;
+});
+export const pruneIds = (row) => mapValues(row, (v, k) => (k === 'id' || (typeof k === 'string' && k.endsWith('_id'))) &&
+    (typeof v === 'string' || typeof v === 'number')
+    ? idReplacement(v)
+    : v);
+export const pruneIdArrays = (row) => mapValues(row, (v, k) => typeof k === 'string' && k.endsWith('_ids') && Array.isArray(v)
+    ? `[UUIDs-${v.length}]`
+    : v);
+export const pruneUUIDs = (row) => mapValues(row, (v, k) => {
+    if (typeof v !== 'string') {
+        return v;
+    }
+    if (['uuid', 'queue_name'].includes(k) && uuidRegexp.test(v)) {
+        return '[UUID]';
+    }
+    if (k === 'gravatar' && /^[0-9a-f]{32}$/i.test(v)) {
+        return '[gUUID]';
+    }
+    return v;
+});
+export const pruneHashes = (row) => mapValues(row, (v, k) => typeof k === 'string' &&
+    k.endsWith('_hash') &&
+    typeof v === 'string' &&
+    v.startsWith('$')
+    ? '[hash]'
+    : v);
+export const prune = (obj) => pruneHashes(pruneUUIDs(pruneIds(pruneIdArrays(pruneDates(obj)))));
+export const snapshot = (obj) => {
+    if (Array.isArray(obj)) {
+        return obj.map(snapshot);
+    }
+    else if (obj && typeof obj === 'object') {
+        return mapValues(prune(obj), snapshot);
+    }
+    return obj;
+};

package/esm/graphile-test.js

@@ -0,0 +1,172 @@
+import { getGraphileSettings } from '@launchql/graphile-settings';
+import pg from 'pg';
+import { createPostGraphileSchema, withPostGraphileContext } from 'postgraphile';
+import { graphql } from 'graphql';
+// @ts-ignore
+import MockReq from 'mock-req';
+import { print } from 'graphql/language/printer';
+import { getEnvOptions } from '@launchql/types';
+const opt = getEnvOptions();
+export const GraphQLTest = ({ dbname, schemas, authRole = 'authenticated' }) => {
+    const getDbString = (db) => `postgres://${opt.pg.user}:${opt.pg.password}@${opt.pg.host}:${opt.pg.port}/${db}`;
+    const options = {
+        ...getGraphileSettings({
+            graphile: {
+                schema: schemas
+            }
+        }),
+        graphqlRoute: '/graphql',
+        graphiqlRoute: '/graphiql'
+    };
+    pg.defaults.poolSize = 1;
+    const POSTGRAPHILE_AUTHENTICATOR_ROLE = authRole;
+    let ctx = null;
+    const setup = async () => {
+        const rootPgPool = new pg.Pool({
+            connectionString: getDbString(dbname)
+        });
+        const schema = await createPostGraphileSchema(rootPgPool, schemas, options);
+        ctx = { rootPgPool, options, schema };
+    };
+    const teardown = async () => {
+        try {
+            if (!ctx)
+                return;
+            const { rootPgPool } = ctx;
+            ctx = null;
+            await rootPgPool.end();
+        }
+        catch (e) {
+            console.error(e);
+        }
+    };
+    const graphQL = async (...args) => {
+        if (!ctx)
+            throw new Error('Context is not initialized. Did you run setup()?');
+        let reqOptions = {};
+        let checker;
+        if (args.length === 1) {
+            checker = args[0];
+        }
+        else if (args.length === 2) {
+            reqOptions = args[0];
+            checker = args[1];
+        }
+        else {
+            throw new Error('Invalid arguments supplied to graphQL');
+        }
+        const { schema, rootPgPool, options } = ctx;
+        const req = new MockReq({
+            url: options.graphqlRoute || '/graphql',
+            method: 'POST',
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json'
+            },
+            ...reqOptions
+        });
+        const pgSettingsGenerator = options.pgSettings;
+        // @ts-ignore
+        const pgSettings = typeof pgSettingsGenerator === 'function' ? await pgSettingsGenerator(req) : pgSettingsGenerator || {};
+        return await withPostGraphileContext({ ...options, pgPool: rootPgPool, pgSettings }, async (context) => {
+            const replacementPgClient = await rootPgPool.connect();
+            await replacementPgClient.query('begin');
+            await replacementPgClient.query("select set_config('role', $1, true)", [POSTGRAPHILE_AUTHENTICATOR_ROLE]);
+            for (const [key, value] of Object.entries(pgSettings)) {
+                await replacementPgClient.query("select set_config($1, $2, true)", [key, String(value)]);
+            }
+            try {
+                const query = async (q, variables) => {
+                    if (typeof q !== 'string')
+                        q = print(q);
+                    return await graphql(schema, q, null, { ...context, pgClient: replacementPgClient }, variables);
+                };
+                return await checker(query, replacementPgClient);
+            }
+            finally {
+                await replacementPgClient.query('rollback');
+                replacementPgClient.release();
+            }
+        });
+    };
+    const graphQLQuery = async (...args) => {
+        if (!ctx)
+            throw new Error('Context is not initialized. Did you run setup()?');
+        let reqOptions = {};
+        let Query;
+        let vars;
+        let commit = false;
+        if (args.length === 1) {
+            Query = args[0];
+        }
+        else if (args.length === 2) {
+            if (typeof args[1] === 'boolean') {
+                Query = args[0];
+                commit = args[1];
+            }
+            else {
+                Query = args[0];
+                vars = args[1];
+            }
+        }
+        else if (args.length === 3) {
+            if (typeof args[2] === 'boolean') {
+                Query = args[0];
+                vars = args[1];
+                commit = args[2];
+            }
+            else {
+                reqOptions = args[0];
+                Query = args[1];
+                vars = args[2];
+            }
+        }
+        else if (args.length === 4) {
+            reqOptions = args[0];
+            Query = args[1];
+            vars = args[2];
+            commit = args[3];
+        }
+        else {
+            throw new Error('Invalid arguments supplied to graphQLQuery');
+        }
+        const { schema, rootPgPool, options } = ctx;
+        const req = new MockReq({
+            url: options.graphqlRoute || '/graphql',
+            method: 'POST',
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json'
+            },
+            ...reqOptions
+        });
+        const pgSettingsGenerator = options.pgSettings;
+        // @ts-ignore
+        const pgSettings = typeof pgSettingsGenerator === 'function' ? await pgSettingsGenerator(req) : pgSettingsGenerator || {};
+        return await withPostGraphileContext({ ...options, pgPool: rootPgPool, pgSettings }, async (context) => {
+            const replacementPgClient = await rootPgPool.connect();
+            await replacementPgClient.query('begin');
+            await replacementPgClient.query("select set_config('role', $1, true)", [POSTGRAPHILE_AUTHENTICATOR_ROLE]);
+            for (const [key, value] of Object.entries(pgSettings)) {
+                await replacementPgClient.query("select set_config($1, $2, true)", [key, String(value)]);
+            }
+            try {
+                if (typeof Query !== 'string')
+                    Query = print(Query);
+                return await graphql(schema, Query, null, { ...context, pgClient: replacementPgClient }, vars);
+            }
+            finally {
+                await replacementPgClient.query(commit ? 'commit' : 'rollback');
+                replacementPgClient.release();
+            }
+        });
+    };
+    return {
+        setup,
+        teardown,
+        graphQL,
+        graphQLQuery,
+        // @ts-ignore
+        withContext: (cb) => cb(ctx)
+    };
+};

package/esm/index.js

@@ -0,0 +1,2 @@
+export * from './clean';
+export * from './graphile-test';

package/graphile-test.d.ts

@@ -0,0 +1,12 @@
+export interface GraphQLTestOptions {
+    dbname: string;
+    schemas: string[];
+    authRole?: string;
+}
+export declare const GraphQLTest: ({ dbname, schemas, authRole }: GraphQLTestOptions) => {
+    setup: () => Promise<void>;
+    teardown: () => Promise<void>;
+    graphQL: (...args: any[]) => Promise<any>;
+    graphQLQuery: (...args: any[]) => Promise<any>;
+    withContext: <T>(cb: (ctx: typeof ctx) => T) => T;
+};

package/graphile-test.js

@@ -0,0 +1,179 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphQLTest = void 0;
+const graphile_settings_1 = require("@launchql/graphile-settings");
+const pg_1 = __importDefault(require("pg"));
+const postgraphile_1 = require("postgraphile");
+const graphql_1 = require("graphql");
+// @ts-ignore
+const mock_req_1 = __importDefault(require("mock-req"));
+const printer_1 = require("graphql/language/printer");
+const types_1 = require("@launchql/types");
+const opt = (0, types_1.getEnvOptions)();
+const GraphQLTest = ({ dbname, schemas, authRole = 'authenticated' }) => {
+    const getDbString = (db) => `postgres://${opt.pg.user}:${opt.pg.password}@${opt.pg.host}:${opt.pg.port}/${db}`;
+    const options = {
+        ...(0, graphile_settings_1.getGraphileSettings)({
+            graphile: {
+                schema: schemas
+            }
+        }),
+        graphqlRoute: '/graphql',
+        graphiqlRoute: '/graphiql'
+    };
+    pg_1.default.defaults.poolSize = 1;
+    const POSTGRAPHILE_AUTHENTICATOR_ROLE = authRole;
+    let ctx = null;
+    const setup = async () => {
+        const rootPgPool = new pg_1.default.Pool({
+            connectionString: getDbString(dbname)
+        });
+        const schema = await (0, postgraphile_1.createPostGraphileSchema)(rootPgPool, schemas, options);
+        ctx = { rootPgPool, options, schema };
+    };
+    const teardown = async () => {
+        try {
+            if (!ctx)
+                return;
+            const { rootPgPool } = ctx;
+            ctx = null;
+            await rootPgPool.end();
+        }
+        catch (e) {
+            console.error(e);
+        }
+    };
+    const graphQL = async (...args) => {
+        if (!ctx)
+            throw new Error('Context is not initialized. Did you run setup()?');
+        let reqOptions = {};
+        let checker;
+        if (args.length === 1) {
+            checker = args[0];
+        }
+        else if (args.length === 2) {
+            reqOptions = args[0];
+            checker = args[1];
+        }
+        else {
+            throw new Error('Invalid arguments supplied to graphQL');
+        }
+        const { schema, rootPgPool, options } = ctx;
+        const req = new mock_req_1.default({
+            url: options.graphqlRoute || '/graphql',
+            method: 'POST',
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json'
+            },
+            ...reqOptions
+        });
+        const pgSettingsGenerator = options.pgSettings;
+        // @ts-ignore
+        const pgSettings = typeof pgSettingsGenerator === 'function' ? await pgSettingsGenerator(req) : pgSettingsGenerator || {};
+        return await (0, postgraphile_1.withPostGraphileContext)({ ...options, pgPool: rootPgPool, pgSettings }, async (context) => {
+            const replacementPgClient = await rootPgPool.connect();
+            await replacementPgClient.query('begin');
+            await replacementPgClient.query("select set_config('role', $1, true)", [POSTGRAPHILE_AUTHENTICATOR_ROLE]);
+            for (const [key, value] of Object.entries(pgSettings)) {
+                await replacementPgClient.query("select set_config($1, $2, true)", [key, String(value)]);
+            }
+            try {
+                const query = async (q, variables) => {
+                    if (typeof q !== 'string')
+                        q = (0, printer_1.print)(q);
+                    return await (0, graphql_1.graphql)(schema, q, null, { ...context, pgClient: replacementPgClient }, variables);
+                };
+                return await checker(query, replacementPgClient);
+            }
+            finally {
+                await replacementPgClient.query('rollback');
+                replacementPgClient.release();
+            }
+        });
+    };
+    const graphQLQuery = async (...args) => {
+        if (!ctx)
+            throw new Error('Context is not initialized. Did you run setup()?');
+        let reqOptions = {};
+        let Query;
+        let vars;
+        let commit = false;
+        if (args.length === 1) {
+            Query = args[0];
+        }
+        else if (args.length === 2) {
+            if (typeof args[1] === 'boolean') {
+                Query = args[0];
+                commit = args[1];
+            }
+            else {
+                Query = args[0];
+                vars = args[1];
+            }
+        }
+        else if (args.length === 3) {
+            if (typeof args[2] === 'boolean') {
+                Query = args[0];
+                vars = args[1];
+                commit = args[2];
+            }
+            else {
+                reqOptions = args[0];
+                Query = args[1];
+                vars = args[2];
+            }
+        }
+        else if (args.length === 4) {
+            reqOptions = args[0];
+            Query = args[1];
+            vars = args[2];
+            commit = args[3];
+        }
+        else {
+            throw new Error('Invalid arguments supplied to graphQLQuery');
+        }
+        const { schema, rootPgPool, options } = ctx;
+        const req = new mock_req_1.default({
+            url: options.graphqlRoute || '/graphql',
+            method: 'POST',
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json'
+            },
+            ...reqOptions
+        });
+        const pgSettingsGenerator = options.pgSettings;
+        // @ts-ignore
+        const pgSettings = typeof pgSettingsGenerator === 'function' ? await pgSettingsGenerator(req) : pgSettingsGenerator || {};
+        return await (0, postgraphile_1.withPostGraphileContext)({ ...options, pgPool: rootPgPool, pgSettings }, async (context) => {
+            const replacementPgClient = await rootPgPool.connect();
+            await replacementPgClient.query('begin');
+            await replacementPgClient.query("select set_config('role', $1, true)", [POSTGRAPHILE_AUTHENTICATOR_ROLE]);
+            for (const [key, value] of Object.entries(pgSettings)) {
+                await replacementPgClient.query("select set_config($1, $2, true)", [key, String(value)]);
+            }
+            try {
+                if (typeof Query !== 'string')
+                    Query = (0, printer_1.print)(Query);
+                return await (0, graphql_1.graphql)(schema, Query, null, { ...context, pgClient: replacementPgClient }, vars);
+            }
+            finally {
+                await replacementPgClient.query(commit ? 'commit' : 'rollback');
+                replacementPgClient.release();
+            }
+        });
+    };
+    return {
+        setup,
+        teardown,
+        graphQL,
+        graphQLQuery,
+        // @ts-ignore
+        withContext: (cb) => cb(ctx)
+    };
+};
+exports.GraphQLTest = GraphQLTest;

package/index.d.ts

@@ -0,0 +1,2 @@
+export * from './clean';
+export * from './graphile-test';

package/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./clean"), exports);
+__exportStar(require("./graphile-test"), exports);