@budibase/shared-core 2.29.27 → 2.29.29

package/dist/filters.d.ts

@@ -45,10 +45,16 @@ export declare class ColumnSplitter {
     tableIds: string[];
     relationshipColumnNames: string[];
     relationships: string[];
-    constructor(tables: Table[]);
+    aliases?: Record<string, string>;
+    columnPrefix?: string;
+    constructor(tables: Table[], opts?: {
+        aliases?: Record<string, string>;
+        columnPrefix?: string;
+    });
     run(key: string): {
         numberPrefix?: string;
         relationshipPrefix?: string;
+        tableName?: string;
         column: string;
     };
 }

package/dist/helpers/schema.d.ts

@@ -4,3 +4,5 @@ export declare function isDeprecatedSingleUserColumn(schema: Pick<FieldSchema, "
     subtype: BBReferenceFieldSubType.USER;
 };
 export declare function isRequired(constraints: FieldConstraints | undefined): boolean;
+export declare function encodeNonAscii(str: string): string;
+export declare function decodeNonAscii(str: string): string;

package/dist/index.js

@@ -10097,7 +10097,7 @@ var AnalyticsEvent = {
   PluginInit: "plugin:init" /* PLUGIN_INIT */
 };
 
-// ../types/src/documents/app/automation.ts
+// ../types/src/documents/app/automation/automation.ts
 var AutomationTriggerStepId = /* @__PURE__ */ ((AutomationTriggerStepId2) => {
   AutomationTriggerStepId2["ROW_SAVED"] = "ROW_SAVED";
   AutomationTriggerStepId2["ROW_UPDATED"] = "ROW_UPDATED";
@@ -10538,6 +10538,8 @@ function validate(cronExpression) {
 // src/helpers/schema.ts
 var schema_exports = {};
 __export(schema_exports, {
+  decodeNonAscii: () => decodeNonAscii,
+  encodeNonAscii: () => encodeNonAscii,
   isDeprecatedSingleUserColumn: () => isDeprecatedSingleUserColumn,
   isRequired: () => isRequired
 });
@@ -10549,6 +10551,17 @@ function isRequired(constraints) {
   const isRequired2 = !!constraints && (typeof constraints.presence !== "boolean" && constraints.presence?.allowEmpty === false || constraints.presence === true);
   return isRequired2;
 }
+function encodeNonAscii(str) {
+  return str.split("").map((char) => {
+    return char.charCodeAt(0) > 127 ? "\\u" + char.charCodeAt(0).toString(16).padStart(4, "0") : char;
+  }).join("");
+}
+function decodeNonAscii(str) {
+  return str.replace(
+    /\\u([0-9a-fA-F]{4})/g,
+    (match, p1) => String.fromCharCode(parseInt(p1, 16))
+  );
+}
 
 // src/filters.ts
 var import_lodash = __toESM(require_lodash());
@@ -10652,7 +10665,7 @@ var getKeyNumbering = (key) => {
   }
 };
 var ColumnSplitter = class {
-  constructor(tables) {
+  constructor(tables, opts) {
     this.tableNames = tables.map((table) => table.name);
     this.tableIds = tables.map((table) => table._id);
     this.relationshipColumnNames = tables.flatMap(
@@ -10661,11 +10674,28 @@ var ColumnSplitter = class {
       )
     );
     this.relationships = this.tableNames.concat(this.tableIds).concat(this.relationshipColumnNames).sort((a, b) => b.length - a.length);
+    if (opts?.aliases) {
+      this.aliases = {};
+      for (const [key, value] of Object.entries(opts.aliases)) {
+        this.aliases[value] = key;
+      }
+    }
+    this.columnPrefix = opts?.columnPrefix;
   }
   run(key) {
     let { prefix, key: splitKey } = getKeyNumbering(key);
+    let tableName = void 0;
+    if (this.aliases) {
+      for (const possibleAlias of Object.keys(this.aliases || {})) {
+        const withDot = `${possibleAlias}.`;
+        if (splitKey.startsWith(withDot)) {
+          tableName = this.aliases[possibleAlias];
+          splitKey = splitKey.slice(withDot.length);
+        }
+      }
+    }
     let relationship;
-    for (let possibleRelationship of this.relationships) {
+    for (const possibleRelationship of this.relationships) {
       const withDot = `${possibleRelationship}.`;
       if (splitKey.startsWith(withDot)) {
         const finalKeyParts = splitKey.split(withDot);
@@ -10675,7 +10705,13 @@ var ColumnSplitter = class {
         break;
       }
     }
+    if (this.columnPrefix) {
+      if (splitKey.startsWith(this.columnPrefix)) {
+        splitKey = decodeNonAscii(splitKey.slice(this.columnPrefix.length));
+      }
+    }
     return {
+      tableName,
       numberPrefix: prefix,
       relationshipPrefix: relationship,
       column: splitKey
@@ -11064,6 +11100,7 @@ __export(utils_exports, {
   filterValueToLabel: () => filterValueToLabel,
   hasSchema: () => hasSchema,
   parallelForeach: () => parallelForeach,
+  trimOtherProps: () => trimOtherProps,
   unreachable: () => unreachable
 });
 function unreachable(value, message = `No such case in exhaustive switch: ${value}`) {
@@ -11110,6 +11147,13 @@ function filterValueToLabel() {
 function hasSchema(test) {
   return typeof test === "object" && !Array.isArray(test) && test !== null && !(test instanceof Date) && Object.keys(test).length > 0;
 }
+function trimOtherProps(object, allowedProps) {
+  const result = Object.keys(object).filter((key) => allowedProps.includes(key)).reduce(
+    (acc, key) => ({ ...acc, [key]: object[key] }),
+    {}
+  );
+  return result;
+}
 
 // src/sdk/index.ts
 var sdk_exports = {};
@@ -11324,7 +11368,7 @@ function canBeDisplayColumn(type) {
 function canBeSortColumn(type) {
   return !!allowSortColumnByType[type];
 }
-function findDuplicateInternalColumns(table, opts) {
+function findDuplicateInternalColumns(table) {
   const casedKeys = Object.keys(table.schema);
   const uncasedKeys = casedKeys.map((colName) => colName.toLowerCase());
   const set = new Set(uncasedKeys);
@@ -11337,11 +11381,9 @@ function findDuplicateInternalColumns(table, opts) {
       }
     }
   }
-  if (!opts?.ignoreProtectedColumnNames) {
-    for (let internalColumn of PROTECTED_INTERNAL_COLUMNS) {
-      if (casedKeys.find((key) => key === internalColumn)) {
-        duplicates.push(internalColumn);
-      }
+  for (let internalColumn of PROTECTED_INTERNAL_COLUMNS) {
+    if (casedKeys.find((key) => key === internalColumn)) {
+      duplicates.push(internalColumn);
     }
   }
   return duplicates;