@xeplr/workflow 1.0.1

package/migrations-auth/0004_flows_access.sql

@@ -0,0 +1,76 @@
+-- 0004_flows_access.sql
+-- The `apis` rows for the FLOWS FACADE — the routes an app that designs
+-- screens talks to (lib/flowsRouter.js, mounted at <mount>/flows).
+--
+-- A SEPARATE MIGRATION rather than an edit to 0001, for the reason 0003 gives:
+-- the migrator records what it has applied by filename and will not re-run a
+-- file whose contents changed, so an edit to 0001 would seed nothing at all.
+--
+-- ── which groups these land in, and why ─────────────────────────────────
+--
+-- The same three the workflow routes already use, because a flow is a
+-- workflow and the questions are the same ones:
+--
+--   workflows:view    listing flows, reading one, reading a run
+--   workflows:create  creating, replacing the steps of a draft, publishing
+--   workflows:run     starting a run, and submitting a screen
+--
+-- SUBMITTING IS A RUN RIGHT, NOT A VIEW RIGHT, and that is the only
+-- non-obvious one. It reads like filling in a form, but it moves a run to its
+-- next step and every side effect the rest of the flow has follows from it.
+-- 0001 put running under workflows:run precisely because a run has side
+-- effects, and a Viewer who can submit a screen can cause all of them.
+--
+-- NO MENU ROWS. There is no page in this product for any of this — the
+-- screens live in another app entirely, and this product's own builder shows a
+-- flow read-only through the workflow pages it already has menus for. A menu
+-- row for a page that does not exist puts a dead item in everyone's rail.
+--
+-- Every insert is insert-if-absent, safe to re-run.
+
+INSERT INTO "apis" (id, name, "apiGroup", "isPublic", "isActive", "mtId1", "recordCreatedDate", "recordModifiedDate")
+SELECT encode(gen_random_bytes(12), 'hex'), name, "group", false, true, '*', now(), now()
+FROM (VALUES
+  ('List flows', 'workflows:view'),
+  ('Get flow', 'workflows:view'),
+  ('Get flow run', 'workflows:view'),
+  ('List flow runs', 'workflows:view'),
+  ('Create flow', 'workflows:create'),
+  ('Replace flow steps', 'workflows:create'),
+  ('Publish flow', 'workflows:create'),
+  ('Start flow run', 'workflows:run'),
+  ('Submit flow screen', 'workflows:run')
+) AS v(name, "group")
+WHERE NOT EXISTS (SELECT 1 FROM "apis" a WHERE a."apiGroup" = v."group" AND a.name = v.name);
+
+-- Super Admin → everything, including whatever was just added.
+INSERT INTO "apisRolesMapping" (id, "roleId", "apiId", "isActive", "mtId1", "recordCreatedDate", "recordModifiedDate")
+SELECT encode(gen_random_bytes(12), 'hex'), r.id, a.id, true, '*', now(), now()
+FROM "roles" r CROSS JOIN "apis" a
+WHERE r.name = 'Super Admin'
+  AND NOT EXISTS (SELECT 1 FROM "apisRolesMapping" m WHERE m."roleId" = r.id AND m."apiId" = a.id);
+
+-- The same matrix 0001 established, re-run so it covers the new rows: its own
+-- inserts only ever saw the apis that existed when it ran.
+INSERT INTO "apisRolesMapping" (id, "roleId", "apiId", "isActive", "mtId1", "recordCreatedDate", "recordModifiedDate")
+SELECT encode(gen_random_bytes(12), 'hex'), r.id, a.id, true, '*', now(), now()
+FROM "roles" r CROSS JOIN "apis" a
+WHERE r.name = 'CompanyAdmin'
+  AND (a."apiGroup" LIKE 'workflows:%' OR a."apiGroup" LIKE 'configuration:%')
+  AND NOT EXISTS (SELECT 1 FROM "apisRolesMapping" m WHERE m."roleId" = r.id AND m."apiId" = a.id);
+
+INSERT INTO "apisRolesMapping" (id, "roleId", "apiId", "isActive", "mtId1", "recordCreatedDate", "recordModifiedDate")
+SELECT encode(gen_random_bytes(12), 'hex'), r.id, a.id, true, '*', now(), now()
+FROM "roles" r CROSS JOIN "apis" a
+WHERE r.name = 'Creator'
+  AND a."apiGroup" IN ('workflows:view', 'workflows:create', 'workflows:run')
+  AND NOT EXISTS (SELECT 1 FROM "apisRolesMapping" m WHERE m."roleId" = r.id AND m."apiId" = a.id);
+
+-- Viewer: workflows:view only. Sees the flows and their runs; starts nothing
+-- and submits nothing.
+INSERT INTO "apisRolesMapping" (id, "roleId", "apiId", "isActive", "mtId1", "recordCreatedDate", "recordModifiedDate")
+SELECT encode(gen_random_bytes(12), 'hex'), r.id, a.id, true, '*', now(), now()
+FROM "roles" r CROSS JOIN "apis" a
+WHERE r.name = 'Viewer'
+  AND a."apiGroup" = 'workflows:view'
+  AND NOT EXISTS (SELECT 1 FROM "apisRolesMapping" m WHERE m."roleId" = r.id AND m."apiId" = a.id);

package/models/Company.js

@@ -0,0 +1,82 @@
+// Company — the top-level tenant (a customer of the workflow product). Plain
+// CRUD record; access is granted per user in the auth DB (userTenantsMapping),
+// not filtered here. When mt is enabled, BaseModel auto-fills mtId from
+// context.
+var { BaseModel } = require('@xeplr/db');
+var { generateId } = require('@xeplr/utils/lib/helpers');
+
+// Cross-DB — company lives in this app's own DB, userTenantsMapping/roles live
+// in auth's. Required lazily inside the hook (not at module load) to sidestep
+// any require-order issues between models/ and lib/auth.js at boot.
+function auth() { return require('../lib/auth'); }
+
+/**
+ * Grants the creator CompanyAdmin on their own new company — otherwise nobody
+ * has a userTenantsMapping row for it and every workspace-scoped route 403s
+ * immediately (mtMembershipMiddleware has no grant to check against).
+ *
+ * Best-effort: logs and swallows rather than failing the company creation
+ * itself. The company still exists either way, a missing grant is recoverable
+ * (an admin can add one), and a rolled-back company creation over a grant
+ * hiccup would not be.
+ */
+async function grantCompanyAdmin(userId, companyId) {
+  var a = auth();
+  await a.ready();
+  var Role = a.model('Role');
+  var UserTenantsMapping = a.model('UserTenantsMapping');
+
+  var role = await Role.query().where({ name: 'CompanyAdmin' }).first();
+  if (!role) return; // not seeded (yet) — skip rather than throw
+
+  var existing = await UserTenantsMapping.query()
+    .where({ userId: userId, level: 'l1', value: companyId }).first();
+  if (existing) return;
+
+  await UserTenantsMapping.query().insert({
+    id: generateId(),
+    userId: userId,
+    level: 'l1',
+    value: companyId,
+    roleId: role.id,
+    isActive: true
+  });
+}
+
+class Company extends BaseModel {
+  static get tableName() { return 'companies'; }
+  static get idColumn() { return 'id'; }
+  static get multiTenant() { return false; }
+
+  static get jsonSchema() {
+    return BaseModel.schema({ required: ['name'] });
+  }
+
+  // queryContext.user comes from genericController's save() — { user: req.user }
+  // set via .context(...) on the insert query. Absent for inserts made outside
+  // an authenticated request (e.g. a migration), in which case this no-ops.
+  //
+  // Deferred via queryContext.afterCommit rather than granted here directly:
+  // this hook fires while the Company insert's transaction is still open, but
+  // grantCompanyAdmin() writes to the AUTH DB on a separate, non-transactional
+  // connection — if a later entry in the same changeset throws and this trx
+  // rolls back, an inline grant would already be committed on the other
+  // connection, orphaned against a companyId that no longer exists.
+  async $afterInsert(queryContext) {
+    await super.$afterInsert(queryContext);
+    if (!queryContext || !Array.isArray(queryContext.afterCommit)) return;
+    if (!queryContext.user || !queryContext.user.id) return;
+
+    var companyId = this.id;
+    var userId = queryContext.user.id;
+    queryContext.afterCommit.push(async function() {
+      try {
+        await grantCompanyAdmin(userId, companyId);
+      } catch (err) {
+        console.error('[Company] failed to grant CompanyAdmin to creator:', err.message);
+      }
+    });
+  }
+}
+
+module.exports = Company;

package/models/Workflow.js

@@ -0,0 +1,63 @@
+var { BaseModel } = require('@xeplr/db');
+
+// The document. Mounted through genericRoute as the parent of `steps` — one
+// POST /workflows/save writes the workflow and its whole step list in a
+// single transaction (see routes/index.js). Everything about a RUN of this
+// document — WorkflowRun, WorkflowStepRun, WorkflowResumeKey,
+// WorkflowRunEdge — is deliberately a separate model family, not part of
+// this hierarchy: a run is not something you edit by saving the workflow.
+
+class Workflow extends BaseModel {
+  static get tableName() { return 'workflows'; }
+  static get idColumn() { return 'id'; }
+
+  static get jsonSchema() {
+    return {
+      type: 'object',
+      required: ['id', 'name'],
+      properties: {
+        id: { type: 'string', maxLength: 25 },
+        name: { type: 'string', maxLength: 255 },
+        // A STABLE, AUTHOR-CHOSEN HANDLE, and only a FLOW has one. The flows
+        // facade addresses a flow by key in its URLs (GET /flows/:key), so the
+        // app that designs the screens refers to it by a name it chose rather
+        // than by an id this database minted. Null for every ordinary
+        // workflow — the builder finds those by id. See migrations/0013.
+        key: { type: ['string', 'null'], maxLength: 64 },
+        description: { type: ['string', 'null'], maxLength: 1000 },
+        // [{ name, type, required, default, description, order }]
+        params: { type: ['array', 'null'] },
+        status: { type: 'string', maxLength: 20 },
+        // WHAT THE BUILDER OFFERS, not what the engine does — 'workflow' (the
+        // action catalogue), 'jobs' (the job list), or 'screens' (a flow,
+        // designed in another app entirely through the /flows facade and
+        // read-only in this product's own builder). workflowRunner never reads
+        // it. See migrations/0012 and 0013.
+        kind: { type: 'string', enum: ['workflow', 'jobs', 'screens'] },
+        isActive: { type: 'boolean' },
+        recordCreatedDate: { type: ['string', 'null'] },
+        recordModifiedDate: { type: ['string', 'null'] },
+        recordCreatedBy: { type: ['string', 'null'], maxLength: 25 },
+        recordModifiedBy: { type: ['string', 'null'], maxLength: 25 }
+      }
+    };
+  }
+
+  $beforeInsert() {
+    super.$beforeInsert();
+    if (!this.status) this.status = 'draft';
+  }
+
+  static get relationMappings() {
+    var WorkflowStep = require('./WorkflowStep');
+    return {
+      steps: {
+        relation: BaseModel.HasManyRelation,
+        modelClass: WorkflowStep,
+        join: { from: 'workflows.id', to: 'workflow_steps.workflowId' }
+      }
+    };
+  }
+}
+
+module.exports = Workflow;

package/models/WorkflowResumeKey.js

@@ -0,0 +1,32 @@
+var { BaseModel } = require('@xeplr/db');
+
+// The entire wait/resume mechanism lives behind this one table — see
+// 0007_workflow_resume_keys.sql for the reasoning. Nothing outside
+// lib/workflowRunner.js should query this model directly; the public surface
+// is workflowRunner.resumeByKey(key, output).
+
+class WorkflowResumeKey extends BaseModel {
+  static get tableName() { return 'workflow_resume_keys'; }
+  static get idColumn() { return 'id'; }
+
+  static get jsonSchema() {
+    return {
+      type: 'object',
+      required: ['id', 'runId', 'stepId', 'key'],
+      properties: {
+        id: { type: 'string', maxLength: 25 },
+        runId: { type: 'string', maxLength: 25 },
+        stepId: { type: 'string', maxLength: 25 },
+        key: { type: 'string', maxLength: 64 },
+        consumedDate: { type: ['string', 'null'] },
+        isActive: { type: 'boolean' },
+        recordCreatedDate: { type: ['string', 'null'] },
+        recordModifiedDate: { type: ['string', 'null'] },
+        recordCreatedBy: { type: ['string', 'null'], maxLength: 25 },
+        recordModifiedBy: { type: ['string', 'null'], maxLength: 25 }
+      }
+    };
+  }
+}
+
+module.exports = WorkflowResumeKey;

package/models/WorkflowRun.js

@@ -0,0 +1,64 @@
+var { BaseModel } = require('@xeplr/db');
+
+// One occurrence of a Workflow. Not part of the workflow document's
+// genericRoute hierarchy — a run is created and driven by lib/workflowRunner,
+// never hand-edited via a document save. Deliberately independent of
+// @xeplr/jobs' Job/JobOccurrence: a workflow ties multiple steps (and, later,
+// possibly jobs) together, but owns its own execution bookkeeping rather than
+// borrowing theirs.
+
+class WorkflowRun extends BaseModel {
+  static get tableName() { return 'workflow_runs'; }
+  static get idColumn() { return 'id'; }
+
+  static get jsonSchema() {
+    return {
+      type: 'object',
+      required: ['id', 'workflowId', 'status'],
+      properties: {
+        id: { type: 'string', maxLength: 25 },
+        workflowId: { type: 'string', maxLength: 25 },
+        status: { type: 'string', enum: ['queued', 'running', 'waiting', 'success', 'failed'] },
+        params: { type: ['object', 'null'] },
+        // Set only on a child run spawned by an 'each' transition — the one
+        // element this occurrence exists to process. See WorkflowRunEdge.
+        item: { type: ['object', 'null'] },
+        trigger: { type: ['string', 'null'], maxLength: 64 },
+        startedAt: { type: ['string', 'null'] },
+        finishedAt: { type: ['string', 'null'] },
+        durationMs: { type: ['integer', 'null'] },
+        error: { type: ['object', 'null'] },
+        isActive: { type: 'boolean' },
+        recordCreatedDate: { type: ['string', 'null'] },
+        recordModifiedDate: { type: ['string', 'null'] },
+        recordCreatedBy: { type: ['string', 'null'], maxLength: 25 },
+        recordModifiedBy: { type: ['string', 'null'], maxLength: 25 }
+      }
+    };
+  }
+
+  $beforeInsert() {
+    super.$beforeInsert();
+    if (!this.status) this.status = 'queued';
+    if (!this.trigger) this.trigger = 'manual';
+  }
+
+  static get relationMappings() {
+    var Workflow = require('./Workflow');
+    var WorkflowStepRun = require('./WorkflowStepRun');
+    return {
+      workflow: {
+        relation: BaseModel.BelongsToOneRelation,
+        modelClass: Workflow,
+        join: { from: 'workflow_runs.workflowId', to: 'workflows.id' }
+      },
+      stepRuns: {
+        relation: BaseModel.HasManyRelation,
+        modelClass: WorkflowStepRun,
+        join: { from: 'workflow_runs.id', to: 'workflow_step_runs.runId' }
+      }
+    };
+  }
+}
+
+module.exports = WorkflowRun;

package/models/WorkflowRunEdge.js

@@ -0,0 +1,49 @@
+var { BaseModel } = require('@xeplr/db');
+
+// The only place a run's family tree lives — see 0008_workflow_run_edges.sql.
+// workflow_steps stays flat; fan-out ancestry is entirely a run-time fact
+// recorded here, never something an authored step definition carries.
+
+class WorkflowRunEdge extends BaseModel {
+  static get tableName() { return 'workflow_run_edges'; }
+  static get idColumn() { return 'id'; }
+
+  static get jsonSchema() {
+    return {
+      type: 'object',
+      required: ['id', 'parentRunId', 'childRunId'],
+      properties: {
+        id: { type: 'string', maxLength: 25 },
+        parentRunId: { type: 'string', maxLength: 25 },
+        childRunId: { type: 'string', maxLength: 25 },
+        sourceStepKey: { type: ['string', 'null'], maxLength: 64 },
+        itemIndex: { type: ['integer', 'null'] },
+        itemKey: { type: ['string', 'null'], maxLength: 255 },
+        item: { type: ['object', 'null'] },
+        isActive: { type: 'boolean' },
+        recordCreatedDate: { type: ['string', 'null'] },
+        recordModifiedDate: { type: ['string', 'null'] },
+        recordCreatedBy: { type: ['string', 'null'], maxLength: 25 },
+        recordModifiedBy: { type: ['string', 'null'], maxLength: 25 }
+      }
+    };
+  }
+
+  static get relationMappings() {
+    var WorkflowRun = require('./WorkflowRun');
+    return {
+      parentRun: {
+        relation: BaseModel.BelongsToOneRelation,
+        modelClass: WorkflowRun,
+        join: { from: 'workflow_run_edges.parentRunId', to: 'workflow_runs.id' }
+      },
+      childRun: {
+        relation: BaseModel.BelongsToOneRelation,
+        modelClass: WorkflowRun,
+        join: { from: 'workflow_run_edges.childRunId', to: 'workflow_runs.id' }
+      }
+    };
+  }
+}
+
+module.exports = WorkflowRunEdge;

package/models/WorkflowStep.js

@@ -0,0 +1,66 @@
+var { BaseModel } = require('@xeplr/db');
+
+class WorkflowStep extends BaseModel {
+  static get tableName() { return 'workflow_steps'; }
+  static get idColumn() { return 'id'; }
+
+  static get jsonSchema() {
+    return {
+      type: 'object',
+      required: ['id', 'workflowId', 'stepKey', 'actionName'],
+      properties: {
+        id: { type: 'string', maxLength: 25 },
+        workflowId: { type: 'string', maxLength: 25 },
+        stepKey: { type: 'string', maxLength: 64 },
+        name: { type: ['string', 'null'], maxLength: 255 },
+        actionName: { type: 'string', maxLength: 128 },
+        values: { type: ['object', 'null'] },
+        kind: { type: 'string', enum: ['auto', 'wait'] },
+        timeoutMs: { type: ['integer', 'null'] },
+        onError: { type: 'string', enum: ['stop', 'continue'] },
+        // [{ condition: expressionHandlerExpr|null, mode: 'single'|'each', target: stepKey|'end_success'|'end_failed' }]
+        transitions: { type: ['array', 'null'] },
+        joinStep: { type: ['string', 'null'], maxLength: 64 },
+        position: { type: 'integer' },
+        // { x, y } canvas pixels — where the builder draws this step. Purely
+        // visual; never read by workflowRunner. See migrations/0009.
+        layout: { type: ['object', 'null'] },
+        // An EXAMPLE of what this step returns, for the builder's field
+        // picker — never what it did return (that is on workflow_step_runs),
+        // and never read by workflowRunner. See migrations/0010.
+        sampleOutput: { type: ['object', 'null'] },
+        // What this step needs the CALLER to supply at run start:
+        // [{ name, type, required, default, description, order, sample? }] —
+        // the same field shape as an action's inputSchema. UNLIKE layout and
+        // sampleOutput, workflowRunner DOES read this: every step's
+        // declaration unions into the schema a run is validated against
+        // before any step executes. See migrations/0011.
+        params: { type: ['array', 'null'] },
+        isActive: { type: 'boolean' },
+        recordCreatedDate: { type: ['string', 'null'] },
+        recordModifiedDate: { type: ['string', 'null'] },
+        recordCreatedBy: { type: ['string', 'null'], maxLength: 25 },
+        recordModifiedBy: { type: ['string', 'null'], maxLength: 25 }
+      }
+    };
+  }
+
+  $beforeInsert() {
+    super.$beforeInsert();
+    if (!this.kind) this.kind = 'auto';
+    if (!this.onError) this.onError = 'stop';
+  }
+
+  static get relationMappings() {
+    var Workflow = require('./Workflow');
+    return {
+      workflow: {
+        relation: BaseModel.BelongsToOneRelation,
+        modelClass: Workflow,
+        join: { from: 'workflow_steps.workflowId', to: 'workflows.id' }
+      }
+    };
+  }
+}
+
+module.exports = WorkflowStep;

package/models/WorkflowStepRun.js

@@ -0,0 +1,49 @@
+var { BaseModel } = require('@xeplr/db');
+
+class WorkflowStepRun extends BaseModel {
+  static get tableName() { return 'workflow_step_runs'; }
+  static get idColumn() { return 'id'; }
+
+  static get jsonSchema() {
+    return {
+      type: 'object',
+      required: ['id', 'runId', 'status'],
+      properties: {
+        id: { type: 'string', maxLength: 25 },
+        runId: { type: 'string', maxLength: 25 },
+        stepId: { type: ['string', 'null'], maxLength: 25 },
+        stepKey: { type: ['string', 'null'], maxLength: 64 },
+        actionName: { type: ['string', 'null'], maxLength: 128 },
+        status: { type: 'string', enum: ['pending', 'running', 'waiting', 'success', 'failed', 'skipped'] },
+        input: { type: ['object', 'null'] },
+        output: { type: ['object', 'null'] },
+        error: { type: ['object', 'null'] },
+        durationMs: { type: ['integer', 'null'] },
+        position: { type: 'integer' },
+        isActive: { type: 'boolean' },
+        recordCreatedDate: { type: ['string', 'null'] },
+        recordModifiedDate: { type: ['string', 'null'] },
+        recordCreatedBy: { type: ['string', 'null'], maxLength: 25 },
+        recordModifiedBy: { type: ['string', 'null'], maxLength: 25 }
+      }
+    };
+  }
+
+  $beforeInsert() {
+    super.$beforeInsert();
+    if (!this.status) this.status = 'pending';
+  }
+
+  static get relationMappings() {
+    var WorkflowRun = require('./WorkflowRun');
+    return {
+      run: {
+        relation: BaseModel.BelongsToOneRelation,
+        modelClass: WorkflowRun,
+        join: { from: 'workflow_step_runs.runId', to: 'workflow_runs.id' }
+      }
+    };
+  }
+}
+
+module.exports = WorkflowStepRun;

package/models/Workspace.js

@@ -0,0 +1,75 @@
+// Workspace — the second tenancy level, under a company. Plain CRUD record;
+// siloed access is granted per workspace in the auth DB. companyId is required
+// (a workspace always belongs to a company).
+//
+// Single MT level (mtLevels: 1) — a workspace row is scoped by its company
+// (mtId1) only. It doesn't have a meaningful mtId2 of its own (a workspace
+// isn't scoped "by workspace"); resources that live INSIDE a workspace
+// (workflows, runs) stay at the app's full registered level count (2: company
+// + workspace) via the default.
+var { BaseModel } = require('@xeplr/db');
+var { generateId } = require('@xeplr/utils/lib/helpers');
+
+// Cross-DB — see Company.js for the identical pattern this mirrors: a
+// CompanyAdmin's l1 grant does NOT imply l2 access (mtMembershipMiddleware
+// checks each configured level independently), so without this, entering a
+// just-created workspace 403s with "Not authorized for workspaceId ..." exactly
+// like an ungranted company did before Company.$afterInsert existed.
+function auth() { return require('../lib/auth'); }
+
+async function grantWorkspaceCreator(userId, workspaceId) {
+  var a = auth();
+  await a.ready();
+  var Role = a.model('Role');
+  var UserTenantsMapping = a.model('UserTenantsMapping');
+
+  var role = await Role.query().where({ name: 'Creator' }).first();
+  if (!role) return; // not seeded (yet) — skip rather than throw
+
+  var existing = await UserTenantsMapping.query()
+    .where({ userId: userId, level: 'l2', value: workspaceId }).first();
+  if (existing) return;
+
+  await UserTenantsMapping.query().insert({
+    id: generateId(),
+    userId: userId,
+    level: 'l2',
+    value: workspaceId,
+    roleId: role.id,
+    isActive: true
+  });
+}
+
+class Workspace extends BaseModel {
+  static get tableName() { return 'workspaces'; }
+  static get idColumn() { return 'id'; }
+  static get mtLevels() { return 1; }
+
+  static get jsonAttributes() { return ['tags']; }
+
+  static get jsonSchema() {
+    return BaseModel.schema({
+      required: ['companyId', 'name'],
+      properties: { tags: { type: ['array', 'null'] } }
+    });
+  }
+
+  // Deferred via queryContext.afterCommit — see Company.js's $afterInsert for
+  // why this can't grant inline.
+  async $afterInsert(queryContext) {
+    await super.$afterInsert(queryContext);
+    if (queryContext && queryContext.user && queryContext.user.id && Array.isArray(queryContext.afterCommit)) {
+      var userId = queryContext.user.id;
+      var workspaceId = this.id;
+      queryContext.afterCommit.push(async function() {
+        try {
+          await grantWorkspaceCreator(userId, workspaceId);
+        } catch (err) {
+          console.error('[Workspace] failed to grant Creator access to creator:', err.message);
+        }
+      });
+    }
+  }
+}
+
+module.exports = Workspace;

package/models/index.js

@@ -0,0 +1,25 @@
+// The domain models. Company and Workspace are the tenancy skeleton every
+// xeplr app starts from. Workflow/WorkflowStep are the document, mounted as a
+// genericRoute hierarchy in routes/index.js. WorkflowRun/WorkflowStepRun/
+// WorkflowResumeKey/WorkflowRunEdge are a separate family — an occurrence of
+// a workflow, driven by lib/workflowRunner, never hand-edited via a document
+// save.
+var Company = require('./Company');
+var Workspace = require('./Workspace');
+var Workflow = require('./Workflow');
+var WorkflowStep = require('./WorkflowStep');
+var WorkflowRun = require('./WorkflowRun');
+var WorkflowStepRun = require('./WorkflowStepRun');
+var WorkflowResumeKey = require('./WorkflowResumeKey');
+var WorkflowRunEdge = require('./WorkflowRunEdge');
+
+module.exports = {
+  Company: Company,
+  Workspace: Workspace,
+  Workflow: Workflow,
+  WorkflowStep: WorkflowStep,
+  WorkflowRun: WorkflowRun,
+  WorkflowStepRun: WorkflowStepRun,
+  WorkflowResumeKey: WorkflowResumeKey,
+  WorkflowRunEdge: WorkflowRunEdge
+};