@gotillit/tllt 0.3.0

package/lib/scheduler-entities.js

@@ -0,0 +1,404 @@
+/**
+ * Descriptor-driven model of the normalized Scheduler REST surface.
+ *
+ * The CLI talks to the Scheduler's normalized REST API, whose write
+ * shapes match the published `/assets/data/schema/scheduler/*` schemas. Two
+ * addressing scopes share the `/api/scheduler` prefix:
+ *
+ *   global    -> /api/scheduler/{endpoint}
+ *   template  -> /api/scheduler/{locationCode}/{dataTemplateId}/{endpoint}
+ *
+ * (The older flattened gateway style `/{endpoint}?dataTemplate={id}` is
+ * deprecated and no longer used.)
+ *
+ * Each descriptor declares:
+ *   entityName  PascalCase; matches the published schema file + snapshot folder.
+ *   endpoint    REST collection segment.
+ *   scope       'global' | 'template'.
+ *   key(obj)    natural key — stable across environments. Composite keys are
+ *               joined with KEY_SEP. Used as the snapshot filename, the diff
+ *               match key, and the live key->id map key for deploy.
+ *   refs        foreign-key references. Each:
+ *                 field        property on the record holding the reference.
+ *                 kind         'id'  resolve the ref's natural key to the
+ *                                    target's numeric id at deploy time (the API
+ *                                    only accepts these refs by id).
+ *                              'key' the API resolves the ref itself from a
+ *                                    natural key carried in the body; send as-is.
+ *                              'drop'redundant with sibling inline *Code fields
+ *                                    the API resolves from; dropped on import.
+ *                 keyFields    fields kept when reducing the ref to portable form
+ *                              (kind 'id'/'key').
+ *                 lookupEntity (kind 'id') entityName whose live collection is
+ *                              searched to resolve the id.
+ *                 keyOf(ref,record) (kind 'id') natural key used for that lookup;
+ *                              must match lookupEntity.key()'s output.
+ *                 nullable     the ref may be null.
+ *   numeric     fields the API validates as numbers (@IsNumber) but serializes
+ *               back as strings (Postgres double precision / float / bigint
+ *               columns come through node-pg as strings). Coerced to Number on
+ *               both import and deploy so snapshots match the schema and writes
+ *               pass validation (pending a server-side fix to converge these).
+ *   templateOf(obj)  (leaf sub-entities only) the numeric dataTemplate id that
+ *               owns this row. A few leaf endpoints (property-values,
+ *               changeover-set-items, availability-template-items,
+ *               material-properties) have no dataTemplateId column and ignore the
+ *               path scope, returning the whole tenant — so the CLI filters them
+ *               client-side by the parent's dataTemplate id (read from `expand`).
+ *
+ * The GET `expand` param is derived from refs of kind id/key (the relations
+ * whose natural keys must be captured on import).
+ */
+
+export const KEY_SEP = ' - ';
+
+/** Strip filesystem-hostile characters so a natural key is a safe filename. */
+export function safeKey(raw) {
+  return String(raw).replace(/[<>:"/\\|?*]/g, '');
+}
+
+const join = (...parts) => parts.map((p) => (p == null ? '' : p)).join(KEY_SEP);
+
+// Global scheduler entities (no location/dataTemplate scoping).
+const GLOBAL_ENTITIES = [
+  {entityName: 'Location', endpoint: 'locations', scope: 'global', key: (o) => o.code},
+  {
+    entityName: 'DataTemplate',
+    endpoint: 'data-templates',
+    scope: 'global',
+    key: (o) => o.name,
+    refs: [
+      {field: 'location', kind: 'id', keyFields: ['code'], lookupEntity: 'Location', keyOf: (r) => r.code, nullable: true},
+    ],
+  },
+  {
+    entityName: 'OptimisationProfile',
+    endpoint: 'optimisation-profiles',
+    scope: 'global',
+    key: (o) => o.name,
+    numeric: ['maxDuration', 'maxPopulation', 'changeoverWeight', 'makespanWeight', 'overdueWeight'],
+  },
+];
+
+// Template-scoped entities, listed in dependency (create) order. Deploy applies
+// creates/updates in this order and deletes in reverse, so a referenced parent
+// always exists before the records that point at it.
+const TEMPLATE_ENTITIES = [
+  {entityName: 'EquipmentClass', endpoint: 'equipment-classes', scope: 'template', key: (o) => o.externalId},
+  {entityName: 'Property', endpoint: 'properties', scope: 'template', key: (o) => o.name},
+  {
+    entityName: 'PropertyValue',
+    endpoint: 'property-values',
+    scope: 'template',
+    key: (o) => join(o.property?.name, o.value),
+    templateOf: (o) => o.property?.dataTemplateId,
+    refs: [
+      {field: 'property', kind: 'id', keyFields: ['name'], lookupEntity: 'Property', keyOf: (r) => r.name},
+    ],
+  },
+  {entityName: 'ChangeoverSet', endpoint: 'changeover-sets', scope: 'template', key: (o) => o.name},
+  {
+    entityName: 'ChangeoverSetItem',
+    endpoint: 'changeover-set-items',
+    scope: 'template',
+    key: (o) => join(o.changeoverSet?.name, o.property?.name, o.fromValue?.value, o.toValue?.value),
+    templateOf: (o) => o.changeoverSet?.dataTemplateId,
+    numeric: ['time'],
+    refs: [
+      {field: 'changeoverSet', kind: 'id', keyFields: ['name'], lookupEntity: 'ChangeoverSet', keyOf: (r) => r.name},
+      {field: 'property', kind: 'id', keyFields: ['name'], lookupEntity: 'Property', keyOf: (r) => r.name},
+      {field: 'fromValue', kind: 'id', keyFields: ['value'], lookupEntity: 'PropertyValue', keyOf: (r, rec) => join(rec.property?.name, r.value)},
+      {field: 'toValue', kind: 'id', keyFields: ['value'], lookupEntity: 'PropertyValue', keyOf: (r, rec) => join(rec.property?.name, r.value)},
+    ],
+  },
+  {
+    entityName: 'Equipment',
+    endpoint: 'equipment',
+    scope: 'template',
+    key: (o) => o.externalId,
+    refs: [
+      {field: 'changeoverSet', kind: 'id', keyFields: ['name'], lookupEntity: 'ChangeoverSet', keyOf: (r) => r.name, nullable: true},
+    ],
+  },
+  {
+    entityName: 'EquipmentClassMembership',
+    endpoint: 'equipment-class-memberships',
+    scope: 'template',
+    key: (o) => join(o.equipment?.externalId, o.equipmentClass?.externalId),
+    refs: [
+      {field: 'equipment', kind: 'id', keyFields: ['externalId'], lookupEntity: 'Equipment', keyOf: (r) => r.externalId},
+      {field: 'equipmentClass', kind: 'id', keyFields: ['externalId'], lookupEntity: 'EquipmentClass', keyOf: (r) => r.externalId},
+    ],
+  },
+  {entityName: 'PersonnelClass', endpoint: 'personnel-classes', scope: 'template', key: (o) => o.externalId},
+  {entityName: 'Personnel', endpoint: 'personnels', scope: 'template', key: (o) => o.externalId},
+  {
+    entityName: 'PersonnelClassMembership',
+    endpoint: 'personnel-class-memberships',
+    scope: 'template',
+    key: (o) => join(o.person?.externalId, o.personnelClass?.externalId),
+    refs: [
+      {field: 'person', kind: 'id', keyFields: ['externalId'], lookupEntity: 'Personnel', keyOf: (r) => r.externalId},
+      {field: 'personnelClass', kind: 'id', keyFields: ['externalId'], lookupEntity: 'PersonnelClass', keyOf: (r) => r.externalId},
+    ],
+  },
+  {entityName: 'AvailabilityTemplate', endpoint: 'availability-templates', scope: 'template', key: (o) => o.name},
+  {
+    entityName: 'AvailabilityTemplateItem',
+    endpoint: 'availability-template-items',
+    scope: 'template',
+    key: (o) => join(o.availabilityTemplate?.name, o.dayOfWeek, o.startTime, o.endTime),
+    templateOf: (o) => o.availabilityTemplate?.dataTemplate?.id,
+    numeric: ['dayOfWeek', 'startTime', 'endTime'],
+    refs: [
+      {field: 'availabilityTemplate', kind: 'id', keyFields: ['name'], lookupEntity: 'AvailabilityTemplate', keyOf: (r) => r.name},
+    ],
+  },
+  {
+    entityName: 'DowntimePeriod',
+    endpoint: 'downtime-periods',
+    scope: 'template',
+    key: (o) => join(o.description, o.startTime, o.endTime),
+  },
+  {
+    entityName: 'EquipmentDowntimePeriod',
+    endpoint: 'equipment-downtime-periods',
+    scope: 'template',
+    key: (o) =>
+      join(
+        o.equipment?.externalId,
+        o.downtimePeriod?.description,
+        o.downtimePeriod?.startTime,
+        o.downtimePeriod?.endTime
+      ),
+    refs: [
+      {field: 'equipment', kind: 'id', keyFields: ['externalId'], lookupEntity: 'Equipment', keyOf: (r) => r.externalId},
+      {
+        field: 'downtimePeriod',
+        kind: 'id',
+        keyFields: ['description', 'startTime', 'endTime'],
+        lookupEntity: 'DowntimePeriod',
+        keyOf: (r) => join(r.description, r.startTime, r.endTime),
+      },
+    ],
+  },
+  {
+    entityName: 'PersonDowntimePeriod',
+    endpoint: 'person-downtime-periods',
+    scope: 'template',
+    key: (o) =>
+      join(
+        o.person?.externalId,
+        o.downtimePeriod?.description,
+        o.downtimePeriod?.startTime,
+        o.downtimePeriod?.endTime
+      ),
+    refs: [
+      {field: 'person', kind: 'id', keyFields: ['externalId'], lookupEntity: 'Personnel', keyOf: (r) => r.externalId},
+      {
+        field: 'downtimePeriod',
+        kind: 'id',
+        keyFields: ['description', 'startTime', 'endTime'],
+        lookupEntity: 'DowntimePeriod',
+        keyOf: (r) => join(r.description, r.startTime, r.endTime),
+      },
+    ],
+  },
+  {entityName: 'MaterialGroup', endpoint: 'material-groups', scope: 'template', key: (o) => o.externalId},
+  {
+    entityName: 'MaterialDefinition',
+    endpoint: 'material-definitions',
+    scope: 'template',
+    key: (o) => o.externalId,
+    // The plain create endpoint needs materialGroup by id (only the /upsert route
+    // resolves it by externalId), so the CLI resolves it.
+    refs: [{field: 'materialGroup', kind: 'id', keyFields: ['externalId'], lookupEntity: 'MaterialGroup', keyOf: (r) => r.externalId}],
+  },
+  {
+    entityName: 'MaterialProperty',
+    endpoint: 'material-properties',
+    scope: 'template',
+    key: (o) => join(o.materialDefinition?.externalId, o.externalId),
+    templateOf: (o) => o.materialDefinition?.dataTemplateId,
+    refs: [{field: 'materialDefinition', kind: 'id', keyFields: ['externalId'], lookupEntity: 'MaterialDefinition', keyOf: (r) => r.externalId}],
+  },
+  {entityName: 'Operation', endpoint: 'operations', scope: 'template', key: (o) => o.operationCode},
+  {
+    entityName: 'Route',
+    endpoint: 'routes',
+    scope: 'template',
+    key: (o) => join(o.operationCode, o.routeCode),
+    // The API resolves the parent operation from the inline operationCode.
+    refs: [{field: 'operation', kind: 'drop'}],
+  },
+  {
+    entityName: 'Segment',
+    endpoint: 'segments',
+    scope: 'template',
+    key: (o) => join(o.operationCode, o.routeCode, o.segmentCode),
+    // The API resolves the parent route from inline operationCode + routeCode.
+    refs: [{field: 'route', kind: 'drop'}],
+  },
+  {
+    entityName: 'SegmentMaterial',
+    endpoint: 'segment-materials',
+    scope: 'template',
+    key: (o) => join(o.operationCode, o.routeCode, o.segmentCode, o.materialUse, o.lineNumber),
+    refs: [
+      {field: 'segment', kind: 'drop'},
+      {field: 'materialDefinition', kind: 'key', keyFields: ['externalId']},
+    ],
+  },
+  {
+    entityName: 'SegmentEquipment',
+    endpoint: 'segment-equipments',
+    scope: 'template',
+    key: (o) => join(o.operationCode, o.routeCode, o.segmentCode, o.equipmentClass?.externalId),
+    refs: [
+      {field: 'segment', kind: 'drop'},
+      // The create endpoint needs equipmentClass by id (it only resolves by
+      // externalId when the controller forwards dataTemplateId, which it doesn't
+      // on create), so the CLI resolves it.
+      {field: 'equipmentClass', kind: 'id', keyFields: ['externalId'], lookupEntity: 'EquipmentClass', keyOf: (r) => r.externalId},
+    ],
+  },
+  {
+    entityName: 'SegmentDependency',
+    endpoint: 'segment-dependencies',
+    scope: 'template',
+    key: (o) => join(o.operationCode, o.routeCode, o.fromSegmentCode, o.toSegmentCode),
+    templateOf: (o) => o.dataTemplateId,
+    // The API resolves both segments from inline operation/route/segment codes.
+    refs: [
+      {field: 'route', kind: 'drop'},
+      {field: 'fromSegment', kind: 'drop'},
+      {field: 'toSegment', kind: 'drop'},
+    ],
+  },
+];
+
+/** All descriptors in deploy (dependency) order: globals first, then scoped. */
+export const SCHEDULER_ENTITIES = [...GLOBAL_ENTITIES, ...TEMPLATE_ENTITIES];
+
+const BY_NAME = new Map(SCHEDULER_ENTITIES.map((d) => [d.entityName, d]));
+
+export function getSchedulerEntity(entityName) {
+  return BY_NAME.get(entityName);
+}
+
+/** Index of an entity in deploy order (for sorting changesets). */
+export function schedulerDeployOrder(entityName) {
+  const i = SCHEDULER_ENTITIES.findIndex((d) => d.entityName === entityName);
+  return i === -1 ? Number.MAX_SAFE_INTEGER : i;
+}
+
+/** Comma-separated `expand` relations to request on GET, or undefined. */
+export function expandParam(desc) {
+  const rels = (desc.refs || [])
+    .filter((r) => r.kind === 'id' || r.kind === 'key')
+    .map((r) => r.field);
+  return rels.length ? rels.join(',') : undefined;
+}
+
+// Volatile/environment-specific fields stripped from every scheduler record.
+const STRIP = new Set([
+  'id',
+  'createdAt',
+  'updatedAt',
+  'dataTemplateId',
+  'availabilitySetId',
+  'dataTemplate',
+  'nestedPath',
+]);
+
+function stripDeep(value) {
+  if (Array.isArray(value)) return value.map(stripDeep);
+  if (value && typeof value === 'object') {
+    const out = {};
+    for (const k of Object.keys(value)) {
+      if (STRIP.has(k)) continue;
+      out[k] = stripDeep(value[k]);
+    }
+    return out;
+  }
+  return value;
+}
+
+function pick(obj, fields) {
+  const out = {};
+  for (const f of fields || []) if (obj[f] !== undefined) out[f] = obj[f];
+  return out;
+}
+
+/** Coerce numeric-but-stringified fields to Number (idempotent, null-safe). */
+function coerceNumeric(rec, desc) {
+  for (const f of desc.numeric || []) {
+    if (rec[f] != null && rec[f] !== '') rec[f] = Number(rec[f]);
+  }
+  return rec;
+}
+
+/**
+ * Reduce a live GET record to a portable, environment-independent snapshot:
+ * strip volatile ids, reduce id/key references to just their natural-key
+ * fields, and drop references the API rebuilds from inline codes.
+ */
+export function toPortable(obj, desc) {
+  const rec = stripDeep(obj);
+  for (const ref of desc.refs || []) {
+    if (ref.kind === 'drop') {
+      delete rec[ref.field];
+      continue;
+    }
+    if (rec[ref.field] == null) continue;
+    rec[ref.field] = pick(rec[ref.field], ref.keyFields);
+  }
+  return coerceNumeric(rec, desc);
+}
+
+/** The natural key as a safe, stable string (filename + match key). */
+export function matchKey(obj, desc) {
+  return safeKey(desc.key(obj));
+}
+
+/**
+ * Produce the deploy body: resolve each kind:'id' reference's natural key to the
+ * target's numeric id using pre-built lookup maps (lookupEntity -> matchKey->id).
+ * Throws with an actionable message if a required reference can't be resolved.
+ */
+export function resolveRefs(record, desc, lookups) {
+  const out = coerceNumeric({...record}, desc);
+  for (const ref of desc.refs || []) {
+    if (ref.kind !== 'id') continue;
+    const val = out[ref.field];
+    if (val == null) {
+      if (ref.nullable) continue;
+      throw new Error(`${desc.entityName}.${ref.field} is required but missing in the snapshot.`);
+    }
+    const wanted = safeKey(ref.keyOf(val, record));
+    const map = lookups.get(ref.lookupEntity);
+    const id = map?.get(wanted);
+    if (id == null) {
+      throw new Error(
+        `Cannot resolve ${desc.entityName}.${ref.field} "${wanted}" — no ${ref.lookupEntity} with that key exists on the target (deploy it first).`
+      );
+    }
+    out[ref.field] = {id};
+  }
+  return out;
+}
+
+/** kind:'id' references whose lookup maps must be built before deploying desc. */
+export function idRefs(desc) {
+  return (desc.refs || []).filter((r) => r.kind === 'id');
+}
+
+/**
+ * Restrict raw GET rows to one dataTemplate. A no-op for entities the API scopes
+ * server-side; for the unscoped leaf endpoints it filters by the parent's
+ * dataTemplate id (see `templateOf`). Operates on raw rows (ids intact).
+ */
+export function scopeRows(rows, desc, dataTemplateId) {
+  if (!desc.templateOf || dataTemplateId == null) return rows;
+  return rows.filter((r) => desc.templateOf(r) === dataTemplateId);
+}

package/lib/schema.js

@@ -0,0 +1,65 @@
+/**
+ * Schema distillation: turn the verbose published entity schema into a compact,
+ * agent-friendly contract so a tool or person editing a record knows each
+ * field's type, whether it's required, allowed enum values, and — crucially —
+ * what entity a nested `{ "name": "..." }` reference points at.
+ *
+ * Both APIs publish the same schema live:
+ *   DO         /assets/data/schema/{Entity}.json
+ *   Scheduler  /assets/data/schema/scheduler/{Entity}.json
+ *
+ * Output shape (the "data dictionary" for one entity):
+ *   {
+ *     api, entity, endpoint, microservice, naturalKey,
+ *     fields:        [ { name, type, required, unique?, readOnly?, enum? } ],
+ *     relationships: [ { name, kind, references, keyField, required? } ]
+ *   }
+ */
+
+/** Distill a published entity schema (/assets/data/schema[/scheduler]/{Entity}.json). */
+export function distillSchema(raw, apiId) {
+  const fields = (raw.fields || []).map((f) => {
+    const rules = f.fieldValidateRules || [];
+    const field = {
+      name: f.fieldName,
+      type: f.dataType || f.fieldType || 'string',
+      required: rules.includes('required') || f.nullable === false,
+    };
+    if (f.unique || rules.includes('unique')) field.unique = true;
+    if (f.readOnly) field.readOnly = true;
+    if (f.translatable) field.translatable = true;
+    // Enums carry their values in `fieldValues` (comma list).
+    if (f.fieldValues) field.enum = String(f.fieldValues).split(',').map((v) => v.trim());
+    return field;
+  });
+
+  const relationships = (raw.relationships || []).map((r) => {
+    const rel = {
+      name: r.relationshipName,
+      kind: r.relationshipType,
+      references: r.otherEntityName,
+      keyField: r.otherEntityField || 'name',
+    };
+    if (r.nullable === false) rel.required = true;
+    return rel;
+  });
+
+  return {
+    api: apiId || (raw.microserviceName === 'scheduler' ? 'scheduler' : 'do'),
+    entity: raw.name,
+    endpoint: raw.endpoint,
+    microservice: raw.microserviceName,
+    naturalKey: naturalKeyFor(fields),
+    fields,
+    relationships,
+  };
+}
+
+/** The stable cross-environment key: the unique+required field, else name/code. */
+function naturalKeyFor(fields) {
+  const unique = fields.find((f) => f.unique && f.required);
+  if (unique) return unique.name;
+  if (fields.some((f) => f.name === 'name')) return 'name';
+  if (fields.some((f) => f.name === 'code')) return 'code';
+  return 'name';
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@gotillit/tllt",
+  "version": "0.3.0",
+  "description": "TilliT CLI — manage TilliT configuration across the Digital Operations and Scheduler APIs. Built to be agent- and install-friendly: bootstrap a connection once, then import / diff / deploy.",
+  "main": "tllt.js",
+  "type": "module",
+  "bin": {
+    "tllt": "tllt.js"
+  },
+  "files": [
+    "tllt.js",
+    "configure.js",
+    "import.js",
+    "diff.js",
+    "deploy.js",
+    "schema.js",
+    "lib/",
+    "docs/",
+    "AGENTS.md",
+    "README.MD"
+  ],
+  "engines": {
+    "node": ">=22.12"
+  },
+  "scripts": {
+    "start": "node tllt.js",
+    "exec": "node tllt.js",
+    "publish-npm": "npm publish --access public"
+  },
+  "author": "Rafael Amaral",
+  "license": "ISC",
+  "dependencies": {
+    "@inquirer/prompts": "^8.5.2",
+    "commander": "^15.0.0",
+    "got": "^15.0.5"
+  }
+}

package/schema.js

@@ -0,0 +1,79 @@
+import {resolveProfile} from './lib/config.js';
+import {fetchAsset} from './lib/client.js';
+import {getApi} from './lib/apis.js';
+import {distillSchema} from './lib/schema.js';
+import {DO_ENTITIES, SCHEDULER_ENTITIES} from './import.js';
+import {info, result} from './lib/output.js';
+
+/**
+ * Describe an entity's data model so an agent knows how to read/create/edit a
+ * record before touching it: field types, required/unique/enum, and which
+ * entity each relationship points at (and by which key).
+ *
+ *   tllt schema                 # list every known entity + its API
+ *   tllt schema Asset           # the contract for one entity (live, DO)
+ *   tllt schema Equipment       # scheduler entity (live, under scheduler/)
+ *   tllt --json schema Asset    # machine-readable
+ *
+ * Both APIs publish the same schema live:
+ *   DO         /assets/data/schema/{Entity}.json
+ *   Scheduler  /assets/data/schema/scheduler/{Entity}.json
+ */
+const SCHEDULER_ENTITY_NAMES = new Set(SCHEDULER_ENTITIES.map((e) => e.entityName));
+
+const doSchema = async (opts = {}) => {
+  const entity = opts.entity;
+  if (!entity) return listEntities();
+
+  const apiId = resolveApi(entity, opts.api);
+  const profile = resolveProfile(opts.profile);
+  const api = getApi(apiId);
+  const raw = await fetchAsset(profile, apiId, `${api.schemaPath}/${entity}.json`);
+  const schema = distillSchema(raw, apiId);
+
+  printSchema(schema);
+  result(null, {ok: true, schema});
+};
+
+function listEntities() {
+  const entities = [
+    ...DO_ENTITIES.map((e) => ({api: 'do', entity: e.entityName})),
+    ...SCHEDULER_ENTITIES.map((e) => ({api: 'scheduler', entity: e.entityName})),
+  ];
+  for (const e of entities) info(`  ${e.api.padEnd(9)} ${e.entity}`);
+  info('\nRun `tllt schema <Entity>` for the full contract.');
+  result(null, {ok: true, entities});
+}
+
+function resolveApi(entity, explicit) {
+  if (explicit) return explicit;
+  return SCHEDULER_ENTITY_NAMES.has(entity) ? 'scheduler' : 'do';
+}
+
+function printSchema(s) {
+  const loc = s.microservice ? `${s.microservice}/${s.endpoint}` : s.endpoint;
+  info(`${s.entity} (${s.api})  endpoint: ${loc}  naturalKey: ${s.naturalKey}`);
+  if (s.fields?.length) {
+    info('Fields:');
+    for (const f of s.fields) {
+      const tags = [
+        f.required ? 'required' : null,
+        f.unique ? 'unique' : null,
+        f.readOnly ? 'readOnly' : null,
+        f.enum ? `enum: ${f.enum.join(', ')}` : null,
+      ]
+        .filter(Boolean)
+        .join('  ');
+      info(`  ${f.name.padEnd(24)} ${String(f.type).padEnd(8)} ${tags}`);
+    }
+  }
+  if (s.relationships?.length) {
+    info('References:');
+    for (const r of s.relationships) {
+      const req = r.required ? ' required' : '';
+      info(`  ${r.name.padEnd(24)} -> ${r.references} (by ${r.keyField}) [${r.kind}]${req}`);
+    }
+  }
+}
+
+export default doSchema;