@engine9/schemas 1.9.0

package/person_email/transforms/outbound/tables.js

@@ -0,0 +1,14 @@
+export default (async function (batch, { PERSON_EMAIL_TABLE }) {
+  const emails = await PERSON_EMAIL_TABLE.select(['person_id', 'email', 'type']).whereIn(
+    'person_id',
+    batch.map((d) => d.id)
+  );
+  const map = {};
+  emails.forEach((r) => {
+    map[r.person_id] = (map[r.person_id] || []).concat({ email: r.email, type: r.type });
+  });
+  batch.forEach((r) => {
+    r.emails = map[r.id] || [];
+  });
+  return batch;
+});

package/person_email/ui.console.json5

@@ -0,0 +1,58 @@
+{
+  routes: {
+    'person/:id/*': {
+      components: {
+        sidebar: {
+          items: [
+            {
+              component: 'Link',
+              properties: {
+                label: 'Emails',
+                to: 'emails'
+              }
+            }
+          ]
+        },
+        main: [
+          {
+            path: 'emails',
+            label: 'Emails',
+            component: 'RecordTable',
+            properties: {
+              table: 'person_email',
+              conditions: [{ eql: 'person_id={{id}}' }],
+              columns: [
+                {
+                  title: 'Id',
+                  dataIndex: 'id',
+                  sorter: true,
+                  width: '20%'
+                },
+                {
+                  title: 'Email',
+                  template: '{{email}}',
+                  width: '40%'
+                },
+                {
+                  title: 'Type',
+                  template: '{{email_type}}',
+                  width: '10%'
+                },
+                {
+                  title: 'Subscription Status',
+                  template: '{{subscription_status}}',
+                  width: '15%'
+                },
+                {
+                  title: 'Modified',
+                  template: '{{date modified_at}}',
+                  width: '15%'
+                }
+              ]
+            }
+          }
+        ]
+      }
+    }
+  }
+}

package/person_email/upsert.test.js

@@ -0,0 +1,126 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import upsertEmails from './transforms/inbound/upsert_tables.js';
+
+describe('person_email upsert_tables', () => {
+  it('merges duplicate email rows in one batch', async () => {
+    const tablesToUpsert = {};
+    await upsertEmails.transform({
+      batch: [
+        { person_id: 1, email: 'donor@example.com', input_id: 'input-a' },
+        { person_id: 1, email: 'donor@example.com', input_id: 'input-b' }
+      ],
+      databaseEmails: [],
+      tablesToUpsert
+    });
+    assert.equal(tablesToUpsert.person_email.length, 1);
+    assert.equal(tablesToUpsert.person_email[0].source_input_id, 'input-a');
+    assert.ok('email_hash_v1' in tablesToUpsert.person_email[0], 'email_hash_v1 key must always exist');
+  });
+
+  it('last batch row wins for subscription_status (Unsub then Sub in one file)', async () => {
+    const tablesToUpsert = {};
+    await upsertEmails.transform({
+      batch: [
+        {
+          person_id: 2,
+          email: 'toggle@example.com',
+          input_id: 'input-a',
+          entry_type: 'EMAIL_UNSUBSCRIBE',
+          subscription_status: 'Unsubscribed'
+        },
+        {
+          person_id: 2,
+          email: 'toggle@example.com',
+          input_id: 'input-b',
+          subscription_status: 'Subscribed'
+        }
+      ],
+      databaseEmails: [],
+      tablesToUpsert
+    });
+    assert.equal(tablesToUpsert.person_email.length, 1);
+    assert.equal(tablesToUpsert.person_email[0].subscription_status, 'Subscribed');
+  });
+
+  it('last batch row wins for subscription_status (Sub then Unsub in one file)', async () => {
+    const tablesToUpsert = {};
+    await upsertEmails.transform({
+      batch: [
+        {
+          person_id: 3,
+          email: 'toggle2@example.com',
+          input_id: 'input-a',
+          subscription_status: 'Subscribed'
+        },
+        {
+          person_id: 3,
+          email: 'toggle2@example.com',
+          input_id: 'input-b',
+          entry_type: 'EMAIL_UNSUBSCRIBE',
+          subscription_status: 'Unsubscribed'
+        }
+      ],
+      databaseEmails: [],
+      tablesToUpsert
+    });
+    assert.equal(tablesToUpsert.person_email.length, 1);
+    assert.equal(tablesToUpsert.person_email[0].subscription_status, 'Unsubscribed');
+  });
+
+  it('queues email_hash_v1 as blank string when missing on some input rows', async () => {
+    const tablesToUpsert = {};
+    await upsertEmails.transform({
+      batch: [
+        { person_id: 10, email: 'a@example.com', input_id: 'input-a', email_hash_v1: 'hash-a' },
+        { person_id: 11, email: 'b@example.com', input_id: 'input-b' }
+      ],
+      databaseEmails: [],
+      tablesToUpsert
+    });
+    assert.equal(tablesToUpsert.person_email.length, 2);
+    const rowA = tablesToUpsert.person_email.find((r) => r.person_id === 10);
+    const rowB = tablesToUpsert.person_email.find((r) => r.person_id === 11);
+    assert.equal(rowA.email_hash_v1, 'hash-a');
+    assert.equal(rowB.email_hash_v1, '', 'missing email_hash_v1 should normalize to blank string');
+  });
+
+  it('normalizes type and email_type onto the same email_type key', async () => {
+    const tablesToUpsert = {};
+    await upsertEmails.transform({
+      batch: [
+        { person_id: 1, email: 'a@example.com', input_id: 'input-a', type: 'Work' },
+        { person_id: 2, email: 'b@example.com', input_id: 'input-a', email_type: 'Other' }
+      ],
+      databaseEmails: [],
+      tablesToUpsert
+    });
+    assert.deepEqual(
+      tablesToUpsert.person_email.map((row) => row.email_type),
+      ['Work', 'Other']
+    );
+    for (const row of tablesToUpsert.person_email) {
+      assert.equal('type' in row, false);
+      assert.equal('email_type' in row, true);
+    }
+  });
+
+  it('keeps the stored email_type when an update does not send one', async () => {
+    const tablesToUpsert = {};
+    await upsertEmails.transform({
+      batch: [{ person_id: 1, email: 'a@example.com', input_id: 'input-a', subscription_status: 'Subscribed' }],
+      databaseEmails: [
+        {
+          id: 9,
+          person_id: 1,
+          email: 'a@example.com',
+          email_type: 'Work',
+          subscription_status: 'Subscribed',
+          source_input_id: 'input-a'
+        }
+      ],
+      tablesToUpsert
+    });
+    assert.equal(tablesToUpsert.person_email[0].email_type, 'Work');
+  });
+});

package/person_hash/README.md

@@ -0,0 +1,70 @@
+# Person Hash Schema Plugin
+
+`@engine9/schemas/person_hash` stores **pseudonymous match keys** for email and phone — SHA-256 (`*_hash_v1`) and MD5 (`*_hash_md5`) — without storing the plaintext.
+
+It is **not** part of the standard stack. It ships in `@engine9/schemas/stacks/limited-pii`, or install it explicitly (once per account — `unique: true`). Once installed, core weaves its transforms into the inbound people pipeline automatically.
+
+Warehouse plugin setting `exclude_pii` on `@engine9/schemas/utilities/limited-pii` makes `installDefaultPlugins()` prefer the limited-pii stack over `default_stack` and refuses `@engine9/schemas/stacks/standard`, `person_email`, `person_phone`, and `person_address` even if those plugins are already installed. That does **not** uninstall leftover plaintext tables. Install the utility plugin on demand; it is not part of the limited-pii stack.
+
+It does **not** depend on `person_email` or `person_phone`. Those plugins may be installed alongside it; this schema plugin never writes to their tables.
+
+## Install
+
+```javascript
+await pluginWorker.install({ path: '@engine9/schemas/person_hash' });
+// or the PII-free stack
+await pluginWorker.installDefaultPlugins({ path: '@engine9/schemas/stacks/limited-pii' });
+```
+
+A second install of the same path reuses the existing plugin row.
+
+## Inbound pipeline slots
+
+`metadata.inbound` declares where the transforms run; core reads it from the installed plugin row and never hardcodes this path:
+
+```javascript
+inbound: {
+  id: ['extractContactHashes'],  // with the other identifier extracts, before person_id assignment
+  upsert: ['upsertPersonHash']   // with the other table upserts, after person_id assignment
+}
+```
+
+How slots and the weaver work: `@engine9/core/lib/peoplePipeline/README.md`.
+
+To see the woven chain for an account: `personWorker.getInboundTransforms({ pluginId, describe: true })` (CLI: `e9 personworker getInboundTransforms --plugin_id=<plugin_id> --describe=true`). On a limited-pii account the listing has `person_hash` on `id` and `upsert` and no `person_email` / `person_phone` / `person_address` lines. Drop a step for one job with `omit_transforms`.
+
+## Data Model
+
+### `person_hash_email`
+
+Primary key: `(person_id, email_hash_v1)`.
+
+| Field | Type | Description |
+| --- | --- | --- |
+| `person_id` | `person_id` | Person that owns the hash. |
+| `email_hash_v1` | `hash` | SHA-256 of the trimmed, lowercased email. Used as the person identifier type `email_hash_v1`. |
+| `email_hash_md5` | `hash` | Legacy MD5 of the trimmed, **uppercased** email. Kept for some political matching contexts; empty when the inbound row had a SHA-256 but no plaintext. |
+| `source_input_id` | `foreign_uuid` | Input that originally created the row. Existing rows keep their original source. |
+| `created_at` / `modified_at` | timestamps | |
+
+### `person_hash_phone`
+
+Primary key: `(person_id, phone_hash_v1)`. Same shape with `phone_hash_v1` / `phone_hash_md5`. Phones are normalized like `person_phone` (digits + optional `+1` for US 10-digit numbers) before hashing.
+
+## Inbound Behavior
+
+The `extractContactHashes` transform hashes `email` / `phone` (or mobile/cell aliases) when present, or accepts an existing `email_hash_v1` / `phone_hash_v1`. It pushes those SHA-256 values as person identifiers. It does not write email or phone onto the hash tables.
+
+The `upsertPersonHash` transform writes only hash columns to `person_hash_email` / `person_hash_phone`.
+
+## Outbound Behavior
+
+- `appendEmailHash` / `appendPhoneHash` attach hashes from plaintext on the row, or from the hash tables by `person_id`. They do not append email or phone.
+
+## Search
+
+`PersonWorker.search` `emails` / `phones` match `person_email` / `person_phone` when those tables exist, and also hash the query (or accept SHA-256 / MD5 hex) against `person_hash_email` / `person_hash_phone`. If the caller passed emails or phones and neither table exists, the clause matches nobody (`1=0`). Related summaries include `email_hashes` / `phone_hashes` when those tables are present.
+
+The plugin also exports `search.emailHashes` / `search.phoneHashes` for the plugin search tree (`@engine9/schemas/person_hash:search:emailHashes`).
+
+Default warehouse export includes the hash tables (export skips them when they do not exist). When utilities/limited-pii `exclude_pii` is set and `tables` is not explicit, `person_email` / `person_phone` / `person_address` are omitted from that default list.

package/person_hash/hash.js

@@ -0,0 +1,103 @@
+import nodecrypto from 'node:crypto';
+
+const { createHash } = nodecrypto;
+
+export const MIN_EMAIL_LENGTH = 5;
+export const MIN_PHONE_LENGTH = 8;
+
+/** SHA-256 hex digest of an empty string — must never be stored as an identifier. */
+export const BLANK_SHA256_HEX = createHash('sha256').update('').digest('hex');
+/** MD5 hex digest of an empty string — must never be stored as a hash. */
+export const BLANK_MD5_HEX = createHash('md5').update('').digest('hex');
+
+export function digestHex(algorithm, value) {
+  return createHash(algorithm).update(String(value), 'utf8').digest('hex');
+}
+
+export function isBlankSha256(value) {
+  return Boolean(value) && value === BLANK_SHA256_HEX;
+}
+
+export function isBlankMd5(value) {
+  return Boolean(value) && value === BLANK_MD5_HEX;
+}
+
+/**
+ * Trim + lowercase. Matching and `email_hash_v1` always use this form;
+ * callers that persist plaintext should keep the original casing.
+ * (`email_hash_md5` uses the uppercased form — see `hashEmail`.)
+ */
+export function normalizeEmail(email) {
+  if (email == null) return '';
+  return String(email).trim().toLowerCase();
+}
+
+/**
+ * SHA-256 (`email_hash_v1`) of the trimmed, lowercased email (industry-standard match key).
+ * MD5 (`email_hash_md5`) of the trimmed, *uppercased* email — legacy; kept for some
+ * political matching contexts that historically hashed uppercase addresses.
+ * Returns null when the email is missing or shorter than MIN_EMAIL_LENGTH.
+ */
+export function hashEmail(email) {
+  const hashable = normalizeEmail(email);
+  if (hashable.length < MIN_EMAIL_LENGTH) return null;
+  return {
+    email_hash_v1: digestHex('sha256', hashable),
+    email_hash_md5: digestHex('md5', hashable.toUpperCase())
+  };
+}
+
+/**
+ * Prefer `phone`, then mobile/cell aliases used on inbound person rows.
+ */
+export function resolvePhoneFromRow(row) {
+  if (!row) return '';
+  if (row.phone) return row.phone;
+  return row.cell || row.mobile || row.mobile_phone || '';
+}
+
+/**
+ * Strip to digits and `+`. US 10-digit numbers get `+1`; 11-digit numbers
+ * starting with `1` get a leading `+`. Numbers already prefixed with `+`
+ * are left as-is. Returns '' when the cleaned value is too short.
+ */
+export function normalizePhone(phone) {
+  let cleaned = String(phone || '')
+    .replace(/[^0-9+]*/g, '')
+    .trim();
+  if (!cleaned || cleaned.length < MIN_PHONE_LENGTH) return '';
+  if (cleaned.indexOf('+') < 0) {
+    if (cleaned.length === 10) cleaned = `+1${cleaned}`;
+    else if (cleaned.length === 11 && cleaned.slice(0, 1) === '1') cleaned = `+${cleaned}`;
+  }
+  return cleaned;
+}
+
+/**
+ * SHA-256 (`phone_hash_v1`) and MD5 (`phone_hash_md5`) of the normalized phone.
+ * Returns null when the phone is missing or too short.
+ */
+export function hashPhone(phone) {
+  const normalized = normalizePhone(phone);
+  if (!normalized) return null;
+  return {
+    phone: normalized,
+    phone_hash_v1: digestHex('sha256', normalized),
+    phone_hash_md5: digestHex('md5', normalized)
+  };
+}
+
+export default {
+  MIN_EMAIL_LENGTH,
+  MIN_PHONE_LENGTH,
+  BLANK_SHA256_HEX,
+  BLANK_MD5_HEX,
+  digestHex,
+  isBlankSha256,
+  isBlankMd5,
+  normalizeEmail,
+  hashEmail,
+  resolvePhoneFromRow,
+  normalizePhone,
+  hashPhone
+};

package/person_hash/hash.test.js

@@ -0,0 +1,165 @@
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { describe, it } from 'node:test';
+import {
+  BLANK_MD5_HEX,
+  BLANK_SHA256_HEX,
+  hashEmail,
+  hashPhone,
+  normalizeEmail,
+  normalizePhone,
+  resolvePhoneFromRow
+} from './hash.js';
+import extractIdentifiers from './transforms/inbound/extract_identifiers.js';
+import upsertHashes from './transforms/inbound/upsert_tables.js';
+
+function sha256(value) {
+  return createHash('sha256').update(value, 'utf8').digest('hex');
+}
+function md5(value) {
+  return createHash('md5').update(value, 'utf8').digest('hex');
+}
+
+describe('person_hash helpers', () => {
+  it('hashes trimmed lowercased email with sha256 and uppercased with md5', () => {
+    const hashes = hashEmail('  TeSt@Example.COM  ');
+    assert.equal(hashes.email_hash_v1, sha256('test@example.com'));
+    assert.equal(hashes.email_hash_md5, md5('TEST@EXAMPLE.COM'));
+    assert.equal(normalizeEmail('  TeSt@Example.COM  '), 'test@example.com');
+  });
+
+  it('rejects short emails', () => {
+    assert.equal(hashEmail('a@b'), null);
+    assert.equal(hashEmail(''), null);
+    assert.equal(hashEmail(null), null);
+  });
+
+  it('normalizes US phones and hashes the E.164 form', () => {
+    const hashes = hashPhone('202-555-0143');
+    assert.equal(hashes.phone, '+12025550143');
+    assert.equal(hashes.phone_hash_v1, sha256('+12025550143'));
+    assert.equal(hashes.phone_hash_md5, md5('+12025550143'));
+    assert.equal(normalizePhone('+12025550143'), '+12025550143');
+    assert.equal(normalizePhone('12025550143'), '+12025550143');
+  });
+
+  it('rejects short phones', () => {
+    assert.equal(hashPhone('555-1212'), null);
+    assert.equal(normalizePhone('555-1212'), '');
+  });
+
+  it('resolves mobile aliases', () => {
+    assert.equal(resolvePhoneFromRow({ mobile_phone: '2025550143' }), '2025550143');
+    assert.equal(resolvePhoneFromRow({ phone: '1', cell: '2' }), '1');
+  });
+
+  it('exposes blank digests', () => {
+    assert.equal(BLANK_SHA256_HEX, sha256(''));
+    assert.equal(BLANK_MD5_HEX, md5(''));
+  });
+});
+
+describe('person_hash extract_identifiers', () => {
+  it('extracts identifiers from plaintext and does not require person_email', async () => {
+    const batch = [{ email: 'Alice@Example.com', phone: '202-555-0143' }];
+    await extractIdentifiers.transform({ batch });
+    assert.equal(batch[0].email_hash_v1, sha256('alice@example.com'));
+    assert.equal(batch[0].email_hash_md5, md5('ALICE@EXAMPLE.COM'));
+    assert.equal(batch[0].phone, '+12025550143');
+    assert.equal(batch[0].phone_hash_v1, sha256('+12025550143'));
+    assert.deepEqual(
+      batch[0].identifiers.map((id) => id.type),
+      ['email_hash_v1', 'phone_hash_v1']
+    );
+    assert.equal(batch[0].identifiers[0].path, 'person_hash_email');
+    assert.equal(batch[0].identifiers[1].path, 'person_hash_phone');
+  });
+
+  it('accepts hash-only inbound without computing md5', async () => {
+    const emailHash = sha256('only-hash@example.com');
+    const batch = [{ email_hash_v1: emailHash }];
+    await extractIdentifiers.transform({ batch });
+    assert.equal(batch[0].email_hash_v1, emailHash);
+    assert.equal(batch[0].email_hash_md5, undefined);
+    assert.equal(batch[0].identifiers[0].value, emailHash);
+  });
+
+  it('keeps an existing phone hash when the phone value is too short', async () => {
+    const phoneHash = sha256('+12025550143');
+    const batch = [{ phone: '123', phone_hash_v1: phoneHash }];
+    await extractIdentifiers.transform({ batch });
+    assert.equal(batch[0].phone_hash_v1, phoneHash);
+    assert.equal(batch[0].identifiers[0].type, 'phone_hash_v1');
+  });
+
+  it('does not push blank hashes', async () => {
+    const batch = [{ email_hash_v1: BLANK_SHA256_HEX, phone_hash_v1: BLANK_SHA256_HEX }];
+    await extractIdentifiers.transform({ batch });
+    assert.equal((batch[0].identifiers || []).length, 0);
+  });
+});
+
+describe('person_hash upsert', () => {
+  it('writes hash columns only and preserves source_input_id', async () => {
+    const emailHash = sha256('a@example.com');
+    const tablesToUpsert = {};
+    await upsertHashes.transform({
+      batch: [
+        {
+          person_id: 9,
+          input_id: 'new-input',
+          email: 'a@example.com',
+          email_hash_v1: emailHash,
+          email_hash_md5: md5('A@EXAMPLE.COM'),
+          given_name: 'Ada'
+        }
+      ],
+      databaseEmailHashes: [
+        {
+          person_id: 9,
+          email_hash_v1: emailHash,
+          email_hash_md5: '',
+          source_input_id: 'original-input'
+        }
+      ],
+      databasePhoneHashes: [],
+      tablesToUpsert
+    });
+    assert.deepEqual(Object.keys(tablesToUpsert), ['person_hash_email']);
+    assert.deepEqual(tablesToUpsert.person_hash_email[0], {
+      person_id: 9,
+      email_hash_v1: emailHash,
+      email_hash_md5: md5('A@EXAMPLE.COM'),
+      source_input_id: 'original-input'
+    });
+    assert.equal('email' in tablesToUpsert.person_hash_email[0], false);
+    assert.equal('given_name' in tablesToUpsert.person_hash_email[0], false);
+  });
+
+  it('skips rows without person_id or usable hashes', async () => {
+    const tablesToUpsert = {};
+    await upsertHashes.transform({
+      batch: [{ email_hash_v1: sha256('x@y.com') }, { person_id: 1 }],
+      databaseEmailHashes: [],
+      databasePhoneHashes: [],
+      tablesToUpsert
+    });
+    assert.deepEqual(tablesToUpsert, {});
+  });
+
+  it('merges duplicate hash rows in one batch', async () => {
+    const emailHash = sha256('dup@example.com');
+    const tablesToUpsert = {};
+    await upsertHashes.transform({
+      batch: [
+        { person_id: 5, input_id: 'input-a', email_hash_v1: emailHash, email_hash_md5: md5('DUP@EXAMPLE.COM') },
+        { person_id: 5, input_id: 'input-b', email_hash_v1: emailHash, email_hash_md5: md5('DUP@EXAMPLE.COM') }
+      ],
+      databaseEmailHashes: [],
+      databasePhoneHashes: [],
+      tablesToUpsert
+    });
+    assert.equal(tablesToUpsert.person_hash_email.length, 1);
+    assert.equal(tablesToUpsert.person_hash_email[0].source_input_id, 'input-a');
+  });
+});

package/person_hash/index.js

@@ -0,0 +1,37 @@
+import schema from './schema.js';
+import search from './search.js';
+import extractContactHashes from './transforms/inbound/extract_identifiers.js';
+import upsertPersonHash from './transforms/inbound/upsert_tables.js';
+import appendEmailHash from './transforms/outbound/appendEmailHash.js';
+import appendPhoneHash from './transforms/outbound/appendPhoneHash.js';
+
+const metadata = {
+  name: '@engine9/schemas/person_hash',
+  unique: true,
+  dependencies: {
+    '@engine9/schemas/person': '>=1.9.0'
+  },
+  // Inbound people pipeline slots -> transform export keys. Core weaves these in
+  // whenever this plugin is installed; it never hardcodes this path.
+  inbound: {
+    id: ['extractContactHashes'],
+    upsert: ['upsertPersonHash']
+  }
+};
+
+export const transforms = {
+  extractContactHashes,
+  upsertPersonHash,
+  appendEmailHash,
+  appendPhoneHash
+};
+
+export { metadata };
+export { schema };
+export { search };
+export default {
+  metadata,
+  schema,
+  transforms,
+  search
+};

package/person_hash/schema.js

@@ -0,0 +1,54 @@
+export const tables = [
+  {
+    name: 'person_hash_email',
+    columns: {
+      person_id: 'person_id',
+      email_hash_v1: {
+        type: 'hash',
+        description: 'SHA-256 hex of the trimmed, lowercased email (identity match key)'
+      },
+      email_hash_md5: {
+        type: 'hash',
+        nullable: true,
+        default_value: '',
+        description:
+          'Legacy MD5 hex of the trimmed, uppercased email (political match contexts); empty when plaintext was not available'
+      },
+      source_input_id: 'foreign_uuid',
+      created_at: 'created_at',
+      modified_at: 'modified_at'
+    },
+    indexes: [
+      { columns: ['person_id', 'email_hash_v1'], primary: true },
+      { columns: ['email_hash_v1'] },
+      { columns: ['email_hash_md5'] }
+    ]
+  },
+  {
+    name: 'person_hash_phone',
+    columns: {
+      person_id: 'person_id',
+      phone_hash_v1: {
+        type: 'hash',
+        description: 'SHA-256 hex of the normalized E.164-style phone (identity match key)'
+      },
+      phone_hash_md5: {
+        type: 'hash',
+        nullable: true,
+        default_value: '',
+        description: 'MD5 hex of the normalized phone; empty when plaintext was not available'
+      },
+      source_input_id: 'foreign_uuid',
+      created_at: 'created_at',
+      modified_at: 'modified_at'
+    },
+    indexes: [
+      { columns: ['person_id', 'phone_hash_v1'], primary: true },
+      { columns: ['phone_hash_v1'] },
+      { columns: ['phone_hash_md5'] }
+    ]
+  }
+];
+export default {
+  tables
+};