@teleporthq/teleport-plugin-next-workflows 0.44.6 → 0.44.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teleporthq/teleport-plugin-next-workflows",
-  "version": "0.44.6",
+  "version": "0.44.7",
   "description": "A plugin for workflow code generation in Next.js projects.",
   "author": "teleportHQ",
   "license": "MIT",
@@ -66,8 +66,8 @@
   },
   "dependencies": {
     "@babel/types": "^7.5.5",
-    "@teleporthq/teleport-shared": "^0.44.5",
+    "@teleporthq/teleport-shared": "^0.44.7",
     "@teleporthq/teleport-types": "^0.44.0"
   },
-  "gitHead": "c763dc9d1d966d36811d04cd422e948a5cd7e841"
+  "gitHead": "a279c1bd1e268a8b7302e2c4fafd45748a1d242a"
 }

package/src/api-route-generator.ts

@@ -527,11 +527,12 @@ function __isStreamingAI(node, config) {
   return config && config.streaming && __streamingAITypes.indexOf(node.type) >= 0;
 }
 
-// One node's result to the browser — never one kept on the server (see segmentReply).
+// One node's result to the browser — never one kept on the server, and a data
+// node's rows without the users table's credentials (see segmentReply).
 function __streamNodeResult(res, nodeId, result) {
   const kept = SEGMENT_CONFIG.nodes.find(function(nd) { return nd.id === nodeId; });
   if (kept && kept.config && kept.config.keepResultOnServer === true && !utils.isBranchingNodeType(kept.type)) return;
-  res.write('data: ' + JSON.stringify({ type: 'node-result', nodeId: nodeId, result: result }) + '\\n\\n');
+  res.write('data: ' + JSON.stringify({ type: 'node-result', nodeId: nodeId, result: utils.withoutCredentialColumns(kept, result) }) + '\\n\\n');
 }
 
 function __collectSegBranchNodes(startId, excludeId) {

package/src/credential-columns-code.ts

@@ -0,0 +1,59 @@
+import { TableAccess } from '@teleporthq/teleport-shared'
+import { DATA_NODE_TYPES } from './data-api-route-generator'
+
+/**
+ * Runtime helpers that leave the auth users table's credential columns out of
+ * the rows a server segment answers the browser with — the columns
+ * `TableAccess.AUTH_CREDENTIAL_COLUMNS` names, the ones every browser read of
+ * the data route is already served without. A data node of a server segment
+ * reads through the data route as the app's own server code, so its rows come
+ * back whole, and the segment's reply (or a streamed node result) is the
+ * browser's copy of them.
+ *
+ * Only the results of the nodes that read rows (`DATA_NODE_TYPES`) are
+ * touched: all the credentials of a row of the users table, the unambiguous
+ * ones of a raw statement's row, whose table is not known. A row is the
+ * result itself (a create or update spreads its row into it), an object it
+ * holds, or an element of an array it holds; column values are not walked.
+ */
+export const generateCredentialColumnsCode = (): string => `
+var __CREDENTIAL_COLUMNS = ${JSON.stringify(TableAccess.AUTH_CREDENTIAL_COLUMNS)};
+var __UNAMBIGUOUS_CREDENTIAL_COLUMNS = ${JSON.stringify(
+  TableAccess.UNAMBIGUOUS_CREDENTIAL_COLUMNS
+)};
+var __CREDENTIAL_TABLES = ${JSON.stringify(TableAccess.AUTH_CREDENTIAL_TABLES)};
+var __ROW_NODE_TYPES = ${JSON.stringify(Array.from(DATA_NODE_TYPES))};
+
+function credentialColumnsOf(node) {
+  if (!node || __ROW_NODE_TYPES.indexOf(node.type) === -1) return [];
+  var tableName = node.config && typeof node.config.tableName === 'string' ? node.config.tableName : '';
+  if (!tableName) return __UNAMBIGUOUS_CREDENTIAL_COLUMNS;
+  var parts = tableName.trim().toLowerCase().replace(/"/g, '').split('.');
+  return __CREDENTIAL_TABLES.indexOf(parts[parts.length - 1]) !== -1 ? __CREDENTIAL_COLUMNS : [];
+}
+
+function withoutColumns(row, columns) {
+  if (!row || typeof row !== 'object' || Array.isArray(row)) return row;
+  var kept = {};
+  Object.keys(row).forEach(function(key) {
+    if (columns.indexOf(String(key).toLowerCase()) === -1) kept[key] = row[key];
+  });
+  return kept;
+}
+
+function withoutRowsColumns(value, columns) {
+  if (Array.isArray(value)) return value.map(function(row) { return withoutColumns(row, columns); });
+  return withoutColumns(value, columns);
+}
+
+function withoutCredentialColumns(node, result) {
+  var columns = credentialColumnsOf(node);
+  if (columns.length === 0 || !result || typeof result !== 'object') return result;
+  if (Array.isArray(result)) return withoutRowsColumns(result, columns);
+  var kept = withoutColumns(result, columns);
+  Object.keys(kept).forEach(function(key) {
+    if (kept[key] && typeof kept[key] === 'object') kept[key] = withoutRowsColumns(kept[key], columns);
+  });
+  return kept;
+}
+`

package/src/data-api-route-generator.ts

@@ -15,7 +15,7 @@ import { generateSqlValidatorCode } from './sql-validator'
 import { generateCommonJsSessionTokenResolverCode } from './session-cookie-resolver'
 import { ContentTables, TableAccess } from '@teleporthq/teleport-shared'
 
-const DATA_NODE_TYPES = new Set([
+export const DATA_NODE_TYPES: ReadonlySet<string> = new Set([
   'data-select',
   'data-create-item',
   'data-update-item',
@@ -677,6 +677,13 @@ function dropMissingOptionalColumns(tableName, entries, colTypes) {
   return kept;
 }
 
+// The row a create or update answers with, whoever asked, without the auth
+// users table's credentials (the columns a browser read is served without):
+// a server-side caller hands that answer on to the browser as its result.
+function withoutCredentialColumns(row, tableName) {
+  return row ? __taWithoutCredentials([row], tableName)[0] : row;
+}
+
 async function handleCreate(client, body) {
   var tableName = body.tableName;
   var columnMappings = body.columnMappings || {};
@@ -751,7 +758,7 @@ async function handleCreate(client, body) {
   var item = result.rows && result.rows[0] ? result.rows[0] : null;
   var idIdx = columns.indexOf('id');
   var resolvedId = item ? (item.id || null) : (idIdx >= 0 ? values[idIdx] : null);
-  return { item: item, id: resolvedId };
+  return { item: withoutCredentialColumns(item, tableName), id: resolvedId };
 }
 
 async function handleUpdate(client, body) {
@@ -803,7 +810,8 @@ async function handleUpdate(client, body) {
   sql += ' RETURNING *';
 
   var result = await safeQuery(client, sql, queryParams, 'update');
-  return { updatedCount: result.rowCount || 0, item: result.rows[0] || null, id: (result.rows[0] && result.rows[0].id) || null };
+  var updated = result.rows[0] || null;
+  return { updatedCount: result.rowCount || 0, item: withoutCredentialColumns(updated, tableName), id: (updated && updated.id) || null };
 }
 
 async function handleDelete(client, body) {

package/src/executor-generator.ts

@@ -4,6 +4,7 @@ import {
   generateWorkflowLocaleHelpersCode,
 } from './email-locale'
 import { generateSignedInDestinationCode } from './auth-return/signed-in-destination-code'
+import { generateCredentialColumnsCode } from './credential-columns-code'
 
 export interface SharedRuntimeUtilsOptions {
   /**
@@ -1414,6 +1415,10 @@ var SEGMENT_REPLY_PRIVATE_KEYS = {
 // nodes after it in the same segment and never leaves the server (a statement's
 // rows read only to build what the browser may see, a sender's recipients).
 // Nothing in a later segment can read it.
+//
+// A data node's rows are replied without the auth users table's credentials
+// (see credential-columns-code.ts).
+${generateCredentialColumnsCode()}
 // The nodes whose result the client branches on: never kept on the server.
 function isBranchingNodeType(type) {
   return type === 'general-if-statement' || type === 'general-switch';
@@ -1425,7 +1430,7 @@ function segmentReply(segmentConfig, context, snapshot) {
   var kept = {};
   var nodes = (segmentConfig && segmentConfig.nodes) || [];
   for (var ni = 0; ni < nodes.length; ni++) {
-    own[nodes[ni].id] = true;
+    own[nodes[ni].id] = nodes[ni];
     if (nodes[ni].config && nodes[ni].config.keepResultOnServer === true && !isBranchingNodeType(nodes[ni].type)) {
       kept[nodes[ni].id] = true;
     }
@@ -1436,7 +1441,11 @@ function segmentReply(segmentConfig, context, snapshot) {
     if (SEGMENT_REPLY_PRIVATE_KEYS[key] || kept[key]) continue;
     var value = context[key];
     if (value === undefined) continue;
-    if (own[key] || !snapshot || !Object.prototype.hasOwnProperty.call(snapshot, key)) {
+    if (own[key]) {
+      reply[key] = withoutCredentialColumns(own[key], value);
+      continue;
+    }
+    if (!snapshot || !Object.prototype.hasOwnProperty.call(snapshot, key)) {
       reply[key] = value;
       continue;
     }
@@ -1504,6 +1513,7 @@ module.exports = {
   loopIterationContext,
   snapshotIncomingContext,
   segmentReply,
+  withoutCredentialColumns,
   evaluateCondition,
   evaluateSingleComparison,
   normalizeComparisonOperator,