@rebasepro/server-postgresql 0.0.1-canary.f81da60 → 0.1.0

package/dist/index.umd.js

@@ -132,7 +132,8 @@
   }
   const DEFAULT_ONE_OF_TYPE = "type";
   const DEFAULT_ONE_OF_VALUE = "value";
-  const snakeCaseRegex = /[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g;
+  const tokenizeRegex = /[A-Z]{2,}(?=[A-Z][a-z]|\b)|[A-Z]?[a-z]+|[0-9]+(?:[a-z](?![a-z]))?|[A-Z]/g;
+  const snakeCaseRegex = tokenizeRegex;
   const toSnakeCase = (str) => {
     const regExpMatchArray = str.match(snakeCaseRegex);
     if (!regExpMatchArray) return "";
@@ -1029,6 +1030,80 @@
     const singularName = snakeCaseName.endsWith("s") ? snakeCaseName.slice(0, -1) : snakeCaseName;
     return `${singularName}_id`;
   }
+  function updateDateAutoValues({
+    inputValues,
+    properties,
+    status,
+    timestampNowValue
+  }) {
+    return traverseValuesProperties(inputValues, properties, (inputValue, property) => {
+      if (property.type === "date") {
+        if (status === "existing" && property.autoValue === "on_update") {
+          return timestampNowValue;
+        } else if ((status === "new" || status === "copy") && (property.autoValue === "on_update" || property.autoValue === "on_create")) {
+          return timestampNowValue;
+        } else {
+          return inputValue;
+        }
+      } else {
+        return inputValue;
+      }
+    }) ?? {};
+  }
+  function traverseValuesProperties(inputValues, properties, operation) {
+    const safeInputValues = inputValues ?? {};
+    const updatedValues = Object.entries(properties).map(([key, property]) => {
+      const inputValue = safeInputValues && safeInputValues[key];
+      const updatedValue = traverseValueProperty(inputValue, property, operation);
+      if (updatedValue === null) return null;
+      if (updatedValue === void 0) return void 0;
+      return {
+        [key]: updatedValue
+      };
+    }).reduce((a, b) => ({
+      ...a,
+      ...b
+    }), {});
+    const result = mergeDeep(safeInputValues, updatedValues);
+    if (!result || Object.keys(result).length === 0) return void 0;
+    return result;
+  }
+  function traverseValueProperty(inputValue, property, operation) {
+    let value;
+    if (property.type === "map" && property.properties) {
+      value = traverseValuesProperties(inputValue, property.properties, operation);
+    } else if (property.type === "array") {
+      const of = property.of;
+      if (of && Array.isArray(inputValue) && !Array.isArray(of)) {
+        value = inputValue.map((e) => traverseValueProperty(e, of, operation));
+      } else if (of && Array.isArray(inputValue) && Array.isArray(of)) {
+        value = inputValue.map((e, i) => {
+          if (i < of.length) return traverseValueProperty(e, of[i], operation);
+          return null;
+        }).filter(Boolean);
+      } else if (property.oneOf && Array.isArray(inputValue)) {
+        const typeField = property.oneOf?.typeField ?? DEFAULT_ONE_OF_TYPE;
+        const valueField = property.oneOf?.valueField ?? DEFAULT_ONE_OF_VALUE;
+        value = inputValue.map((e) => {
+          if (e === null) return null;
+          if (typeof e !== "object") return e;
+          const rec = e;
+          const type = rec[typeField];
+          const childProperty = property.oneOf?.properties[type];
+          if (!type || !childProperty) return e;
+          return {
+            [typeField]: type,
+            [valueField]: traverseValueProperty(rec[valueField], childProperty, operation)
+          };
+        });
+      } else {
+        value = inputValue;
+      }
+    } else {
+      value = operation(inputValue, property);
+    }
+    return value;
+  }
   function createRelationRef(id, path2) {
     return {
       id,
@@ -2616,8 +2691,8 @@
     var freeExports = exports$1 && !exports$1.nodeType && exports$1;
     var freeModule = freeExports && true && module2 && !module2.nodeType && module2;
     var moduleExports = freeModule && freeModule.exports === freeExports;
-    var Buffer = moduleExports ? root2.Buffer : void 0;
-    var nativeIsBuffer = Buffer ? Buffer.isBuffer : void 0;
+    var Buffer2 = moduleExports ? root2.Buffer : void 0;
+    var nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : void 0;
     var isBuffer2 = nativeIsBuffer || stubFalse2;
     module2.exports = isBuffer2;
   })(isBuffer$2, isBuffer$2.exports);
@@ -2782,7 +2857,7 @@
     var freeExports = exports$1 && !exports$1.nodeType && exports$1;
     var freeModule = freeExports && true && module2 && !module2.nodeType && module2;
     var moduleExports = freeModule && freeModule.exports === freeExports;
-    var Buffer = moduleExports ? root2.Buffer : void 0, allocUnsafe = Buffer ? Buffer.allocUnsafe : void 0;
+    var Buffer2 = moduleExports ? root2.Buffer : void 0, allocUnsafe = Buffer2 ? Buffer2.allocUnsafe : void 0;
     function cloneBuffer2(buffer, isDeep) {
       if (isDeep) {
         return buffer.slice();
@@ -4485,7 +4560,25 @@
           return result;
         }
         return value;
+      case "string":
+        if (typeof value === "string") {
+          if (value.startsWith("data:application/octet-stream;base64,")) {
+            const base64Data = value.split(",")[1];
+            if (base64Data) {
+              return Buffer.from(base64Data, "base64");
+            }
+          }
+        }
+        return value;
       default:
+        if (typeof value === "string") {
+          if (value.startsWith("data:application/octet-stream;base64,")) {
+            const base64Data = value.split(",")[1];
+            if (base64Data) {
+              return Buffer.from(base64Data, "base64");
+            }
+          }
+        }
         return value;
     }
   }
@@ -4611,6 +4704,37 @@
       return value;
     }
     switch (property.type) {
+      case "string": {
+        if (typeof value === "string") return value;
+        let isBuffer2 = false;
+        let buf = null;
+        if (Buffer.isBuffer(value)) {
+          isBuffer2 = true;
+          buf = value;
+        } else if (typeof value === "object" && value !== null && value.type === "Buffer" && Array.isArray(value.data)) {
+          isBuffer2 = true;
+          buf = Buffer.from(value.data);
+        }
+        if (isBuffer2 && buf) {
+          let isPrintable = true;
+          for (let i = 0; i < buf.length; i++) {
+            const b = buf[i];
+            if ((b < 32 || b > 126) && b !== 9 && b !== 10 && b !== 13) {
+              isPrintable = false;
+              break;
+            }
+          }
+          return isPrintable ? buf.toString("utf8") : `data:application/octet-stream;base64,${buf.toString("base64")}`;
+        }
+        if (typeof value === "object" && value !== null) {
+          try {
+            return JSON.stringify(value);
+          } catch {
+            return String(value);
+          }
+        }
+        return String(value);
+      }
       case "relation":
         if (typeof value === "string" || typeof value === "number") {
           let relationDef = property.relation;
@@ -4694,8 +4818,29 @@
         }
         return null;
       }
-      default:
+      default: {
+        let isBuffer2 = false;
+        let buf = null;
+        if (Buffer.isBuffer(value)) {
+          isBuffer2 = true;
+          buf = value;
+        } else if (typeof value === "object" && value !== null && value.type === "Buffer" && Array.isArray(value.data)) {
+          isBuffer2 = true;
+          buf = Buffer.from(value.data);
+        }
+        if (isBuffer2 && buf) {
+          let isPrintable = true;
+          for (let i = 0; i < buf.length; i++) {
+            const b = buf[i];
+            if ((b < 32 || b > 126) && b !== 9 && b !== 10 && b !== 13) {
+              isPrintable = false;
+              break;
+            }
+          }
+          return isPrintable ? buf.toString("utf8") : `data:application/octet-stream;base64,${buf.toString("base64")}`;
+        }
         return value;
+      }
     }
   }
   function normalizeScalarValues(data, properties, collection, resolvedRelations, options) {
@@ -5963,6 +6108,10 @@
           await this.resolveJoinPathRelations(entity, collection, collectionPath, parsedId, databaseId);
           return entity;
         } catch (e) {
+          if (e instanceof Error && e.message.includes("not enough information to infer relation")) {
+            console.error(`[EntityFetchService] Relation inference error for collection '${collectionPath}': ${e.message}`);
+            console.error(`Hint: This usually means a relation in your drizzle schema is missing a reciprocal 'one()' or 'many()' definition. Run 'rebase schema generate' to fix this.`);
+          }
           console.warn(`[EntityFetchService] db.query.findFirst failed for ${collectionPath}, falling back to db.select:`, e);
         }
       }
@@ -6023,6 +6172,10 @@
           const entities = results2.map((row) => this.drizzleResultToEntity(row, collection, collectionPath, idInfo, options.databaseId, idInfoArray));
           return entities;
         } catch (e) {
+          if (e instanceof Error && e.message.includes("not enough information to infer relation")) {
+            console.error(`[EntityFetchService] Relation inference error for collection '${collectionPath}': ${e.message}`);
+            console.error(`Hint: This usually means a relation in your drizzle schema is missing a reciprocal 'one()' or 'many()' definition. Run 'rebase schema generate' to fix this.`);
+          }
           console.warn(`[EntityFetchService] db.query.findMany failed for ${collectionPath}, falling back to db.select:`, e);
         }
       }
@@ -6292,6 +6445,10 @@
           await this.resolveJoinPathRelationsBatchRest(restRows, collection, collectionPath, idInfoArray, include);
           return restRows;
         } catch (e) {
+          if (e instanceof Error && e.message.includes("not enough information to infer relation")) {
+            console.error(`[EntityFetchService] Relation inference error for collection '${collectionPath}': ${e.message}`);
+            console.error(`Hint: This usually means a relation in your drizzle schema is missing a reciprocal 'one()' or 'many()' definition. Run 'rebase schema generate' to fix this.`);
+          }
           console.warn(`[fetchCollectionForRest] db.query.findMany failed for ${collectionPath}, falling back:`, e);
         }
       }
@@ -6372,6 +6529,10 @@
           await this.resolveJoinPathRelationsBatchRest([restRow], collection, collectionPath, idInfoArray, include);
           return restRow;
         } catch (e) {
+          if (e instanceof Error && e.message.includes("not enough information to infer relation")) {
+            console.error(`[EntityFetchService] Relation inference error for collection '${collectionPath}': ${e.message}`);
+            console.error(`Hint: This usually means a relation in your drizzle schema is missing a reciprocal 'one()' or 'many()' definition. Run 'rebase schema generate' to fix this.`);
+          }
           console.warn(`[fetchEntityForRest] db.query.findFirst failed for ${collectionPath}, falling back:`, e);
         }
       }
@@ -6765,22 +6926,78 @@
       const pgError = this.extractPgError(error);
       if (pgError) {
         const detail = pgError.detail;
+        const hint = pgError.hint;
         const constraint = pgError.constraint;
         const column = pgError.column;
         const table = pgError.table;
+        const dataType = pgError.dataType;
+        const pgMessage = pgError.message || "Unknown database error";
+        const suffix = hint ? ` Hint: ${hint}` : "";
+        const tableRef = table ?? collectionSlug;
         switch (pgError.code) {
           case "23503":
-            return new Error(detail ? `Foreign key constraint violated: ${detail}` : `Cannot save: a foreign key constraint${constraint ? ` (${constraint})` : ""} was violated in "${collectionSlug}".`);
+            return new Error(detail ? `Foreign key constraint violated: ${detail}${suffix}` : `Cannot save: a foreign key constraint${constraint ? ` (${constraint})` : ""} was violated in "${collectionSlug}".${suffix}`);
           case "23505":
-            return new Error(detail ? `Duplicate value: ${detail}` : `Cannot save: a unique constraint${constraint ? ` (${constraint})` : ""} was violated in "${collectionSlug}".`);
+            return new Error(detail ? `Duplicate value: ${detail}${suffix}` : `Cannot save: a unique constraint${constraint ? ` (${constraint})` : ""} was violated in "${collectionSlug}".${suffix}`);
           case "23502":
-            return new Error(`Missing required field: "${column ?? "unknown"}" in "${table ?? collectionSlug}" cannot be empty.`);
+            return new Error(`Missing required field: "${column ?? "unknown"}" in "${tableRef}" cannot be empty.${suffix}`);
           case "23514":
-            return new Error(`Validation failed: a check constraint${constraint ? ` (${constraint})` : ""} was violated in "${collectionSlug}".`);
+            return new Error(`Validation failed: a check constraint${constraint ? ` (${constraint})` : ""} was violated in "${collectionSlug}".${suffix}`);
+          case "22P02":
+            return new Error(`Invalid data format in "${collectionSlug}": ${pgMessage}${suffix}`);
+          case "22001":
+            return new Error(`Value too long for column "${column ?? "unknown"}" in "${tableRef}": ${pgMessage}${suffix}`);
+          case "22003":
+            return new Error(`Numeric value out of range for column "${column ?? "unknown"}" in "${tableRef}": ${pgMessage}${suffix}`);
+          case "42703":
+            return new Error(`Unknown column in "${tableRef}": ${pgMessage}. Check if your schema is up to date (run migrations).${suffix}`);
+          case "42P01":
+            return new Error(`Table not found for "${collectionSlug}": ${pgMessage}. Check if your schema is up to date (run migrations).${suffix}`);
+          default: {
+            const parts = [`Database error in "${collectionSlug}" [${pgError.code}]: ${pgMessage}`];
+            if (detail) parts.push(`Detail: ${detail}`);
+            if (column) parts.push(`Column: ${column}`);
+            if (dataType) parts.push(`Data type: ${dataType}`);
+            if (constraint) parts.push(`Constraint: ${constraint}`);
+            if (hint) parts.push(`Hint: ${hint}`);
+            return new Error(parts.join(". "));
+          }
+        }
+      }
+      const causeMessage = this.extractCauseMessage(error);
+      if (causeMessage) {
+        return new Error(`Database error in "${collectionSlug}": ${causeMessage}`);
+      }
+      if (error instanceof Error) {
+        const cleaned = this.stripSqlFromMessage(error.message, collectionSlug);
+        return new Error(cleaned);
+      }
+      return new Error(`Database error in "${collectionSlug}": ${String(error)}`);
+    }
+    /**
+     * Walk the error cause chain and return the deepest meaningful message.
+     */
+    extractCauseMessage(error) {
+      if (!error || typeof error !== "object") return null;
+      const err = error;
+      if (err.cause && typeof err.cause === "object") {
+        const deeper = this.extractCauseMessage(err.cause);
+        if (deeper) return deeper;
+        if (err.cause instanceof Error && err.cause.message) {
+          return err.cause.message;
         }
       }
-      if (error instanceof Error) return error;
-      return new Error(String(error));
+      return null;
+    }
+    /**
+     * Strip the raw SQL query from a Drizzle "Failed query: ..." message,
+     * keeping only the error description.
+     */
+    stripSqlFromMessage(message, collectionSlug) {
+      if (message.startsWith("Failed query:")) {
+        return `Failed to save entity in "${collectionSlug}". Check server logs for details.`;
+      }
+      return message;
     }
     /**
      * Extract the underlying PostgreSQL error from a Drizzle wrapper.
@@ -6789,7 +7006,7 @@
     extractPgError(error) {
       if (!error || typeof error !== "object") return null;
       const err = error;
-      if (err.code && /^[0-9]{5}$/.test(err.code)) {
+      if (err.code && /^[0-9A-Z]{5}$/.test(err.code)) {
         return err;
       }
       if (err.cause && typeof err.cause === "object") {
@@ -7077,6 +7294,7 @@
     branchService;
     user;
     data;
+    client;
     /**
      * When true, realtime notifications are deferred until after the
      * wrapping transaction commits.  Set by `withAuth` → `withTransaction`.
@@ -7166,7 +7384,8 @@
         const contextForCallback = {
           user: this.user,
           driver: this,
-          data: this.data
+          data: this.data,
+          client: this.client
         };
         return Promise.all(entities.map(async (entity) => {
           let fetched = entity;
@@ -7260,7 +7479,8 @@
         const contextForCallback = {
           user: this.user,
           driver: this,
-          data: this.data
+          data: this.data,
+          client: this.client
         };
         if (callbacks?.afterRead) {
           entity = await callbacks.afterRead({
@@ -7329,7 +7549,8 @@
       const contextForCallback = {
         user: this.user,
         driver: this,
-        data: this.data
+        data: this.data,
+        client: this.client
       };
       let previousValuesForHistory;
       if (status === "existing" && entityId) {
@@ -7364,6 +7585,14 @@
           if (result) updatedValues = mergeDeep(updatedValues, result);
         }
       }
+      if (resolvedCollection?.properties) {
+        updatedValues = updateDateAutoValues({
+          inputValues: updatedValues,
+          properties: resolvedCollection.properties,
+          status: status ?? "new",
+          timestampNowValue: /* @__PURE__ */ new Date()
+        });
+      }
       try {
         let savedEntity = await this.entityService.saveEntity(path2, updatedValues, entityId, resolvedCollection?.databaseId);
         if (savedEntity && (callbacks?.afterRead || propertyCallbacks?.afterRead)) {
@@ -7469,7 +7698,8 @@
       const contextForCallback = {
         user: this.user,
         driver: this,
-        data: this.data
+        data: this.data,
+        client: this.client
       };
       if (callbacks?.beforeDelete || propertyCallbacks?.beforeDelete) {
         if (callbacks?.beforeDelete) {
@@ -7796,6 +8026,7 @@
         txDelegate.entityService = txEntityService;
         txDelegate._deferNotifications = true;
         txDelegate._pendingNotifications = pendingNotifications;
+        txDelegate.client = this.delegate.client;
         return await operation(txDelegate);
       });
       for (const notification of pendingNotifications) {
@@ -8077,6 +8308,12 @@
       references: [users.id]
     })
   }));
+  const resolveColumnName = (propName, prop) => {
+    if (prop && "columnName" in prop && typeof prop.columnName === "string") {
+      return prop.columnName;
+    }
+    return toSnakeCase(propName);
+  };
   const getPrimaryKeyProp = (collection) => {
     if (collection.properties) {
       const idPropEntry = Object.entries(collection.properties).find(([_, prop]) => "isId" in prop && Boolean(prop.isId));
@@ -8117,7 +8354,7 @@
     return !hasExplicitId && propName === "id";
   };
   const getDrizzleColumn = (propName, prop, collection, collections) => {
-    const colName = toSnakeCase(propName);
+    const colName = resolveColumnName(propName, prop);
     let columnDefinition;
     switch (prop.type) {
       case "string": {
@@ -8189,6 +8426,9 @@
         } else {
           columnDefinition = `timestamp("${colName}", { withTimezone: true, mode: 'string' })`;
         }
+        if (dateProp.autoValue === "on_create" || dateProp.autoValue === "on_update") {
+          columnDefinition += `.default(sql\`now()\`)`;
+        }
         break;
       }
       case "map":
@@ -8221,7 +8461,7 @@
         } catch {
           return null;
         }
-        const fkColumnName = toSnakeCase(relation.localKey);
+        const fkColumnName = relation.localKey;
         const targetTableVar = getTableVarName(getTableName(targetCollection));
         const pkProp = getPrimaryKeyProp(targetCollection);
         const targetIdField = pkProp.name;
@@ -8409,7 +8649,7 @@
       Object.entries(collection.properties ?? {}).forEach(([propName, prop]) => {
         if ("enum" in prop && (prop.type === "string" || prop.type === "number") && prop.enum) {
           const enumVarName = getEnumVarName(collectionPath, propName);
-          const enumDbName = `${collectionPath}_${toSnakeCase(propName)}`;
+          const enumDbName = `${collectionPath}_${resolveColumnName(propName, prop)}`;
           const values = Array.isArray(prop.enum) ? prop.enum.map((v) => String(v.id ?? v)) : Object.keys(prop.enum);
           if (values.length > 0) {
             schemaContent += `export const ${enumVarName} = pgEnum("${enumDbName}", [${values.map((v) => `'${v}'`).join(", ")}]);
@@ -8466,9 +8706,9 @@
         const targetId = getPrimaryKeyName(targetCollection);
         schemaContent += `export const ${tableVarName} = pgTable("${tableName}", {
 `;
-        schemaContent += `    ${sourceColumn}: ${sourceColType}("${toSnakeCase(sourceColumn)}").notNull().references(() => ${getTableVarName(getTableName(sourceCollection))}.${sourceId}, ${refOptions}),
+        schemaContent += `    ${sourceColumn}: ${sourceColType}("${sourceColumn}").notNull().references(() => ${getTableVarName(getTableName(sourceCollection))}.${sourceId}, ${refOptions}),
 `;
-        schemaContent += `    ${targetColumn}: ${targetColType}("${toSnakeCase(targetColumn)}").notNull().references(() => ${getTableVarName(getTableName(targetCollection))}.${targetId}, ${refOptions}),
+        schemaContent += `    ${targetColumn}: ${targetColType}("${targetColumn}").notNull().references(() => ${getTableVarName(getTableName(targetCollection))}.${targetId}, ${refOptions}),
 `;
         schemaContent += "}, (table) => ({\n";
         schemaContent += `    pk: primaryKey({ columns: [table.${sourceColumn}, table.${targetColumn}] })
@@ -8592,6 +8832,32 @@
             console.warn(`Could not generate relation ${relationKey} for ${collection.name}:`, e);
           }
         }
+        for (const otherCollection of collections) {
+          if (otherCollection.slug === collection.slug) continue;
+          const otherRelations = resolveCollectionRelations(otherCollection);
+          for (const [otherKey, otherRel] of Object.entries(otherRelations)) {
+            if (otherRel.direction === "inverse" && otherRel.foreignKeyOnTarget) {
+              try {
+                const otherTarget = otherRel.target();
+                if (otherTarget.slug === collection.slug) {
+                  const drizzleRelationName = computeSharedRelationName(otherRel, otherCollection, collections);
+                  const deduplicationKey = `${drizzleRelationName}::owning`;
+                  if (!emittedRelationNames.has(deduplicationKey)) {
+                    const otherTableVar = getTableVarName(getTableName(otherCollection));
+                    const synthKey = `_synth_${otherTableVar}_${otherRel.foreignKeyOnTarget}`;
+                    tableRelations.push(`    "${synthKey}": one(${otherTableVar}, {
+        fields: [${tableVarName}.${otherRel.foreignKeyOnTarget}],
+        references: [${otherTableVar}.${getPrimaryKeyName(otherCollection)}],
+        relationName: "${drizzleRelationName}"
+    })`);
+                    emittedRelationNames.add(deduplicationKey);
+                  }
+                }
+              } catch (e) {
+              }
+            }
+          }
+        }
       }
       if (tableRelations.length > 0) {
         const relVarName = `${tableVarName}Relations`;