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

package/dist/index.es.js

@@ -124,7 +124,8 @@ function getDataSourceCapabilities(driver) {
 }
 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 "";
@@ -1021,6 +1022,80 @@ function generateForeignKeyName(name) {
   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,
@@ -2608,8 +2683,8 @@ isBuffer$2.exports;
   var freeExports = exports$1 && !exports$1.nodeType && exports$1;
   var freeModule = freeExports && true && module && !module.nodeType && module;
   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;
   module.exports = isBuffer2;
 })(isBuffer$2, isBuffer$2.exports);
@@ -2774,7 +2849,7 @@ _cloneBuffer.exports;
   var freeExports = exports$1 && !exports$1.nodeType && exports$1;
   var freeModule = freeExports && true && module && !module.nodeType && module;
   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();
@@ -4477,7 +4552,25 @@ function serializePropertyToServer(value, property) {
         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;
   }
 }
@@ -4603,6 +4696,37 @@ function parsePropertyFromServer(value, property, collection, propertyKey) {
     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;
@@ -4686,8 +4810,29 @@ function parsePropertyFromServer(value, property, collection, propertyKey) {
       }
       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) {
@@ -5955,6 +6100,10 @@ class EntityFetchService {
         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);
       }
     }
@@ -6015,6 +6164,10 @@ class EntityFetchService {
         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);
       }
     }
@@ -6284,6 +6437,10 @@ class EntityFetchService {
         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);
       }
     }
@@ -6364,6 +6521,10 @@ class EntityFetchService {
         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);
       }
     }
@@ -6757,22 +6918,78 @@ class EntityPersistService {
     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.
@@ -6781,7 +6998,7 @@ class EntityPersistService {
   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") {
@@ -7069,6 +7286,7 @@ class PostgresBackendDriver {
   branchService;
   user;
   data;
+  client;
   /**
    * When true, realtime notifications are deferred until after the
    * wrapping transaction commits.  Set by `withAuth` → `withTransaction`.
@@ -7158,7 +7376,8 @@ class PostgresBackendDriver {
       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;
@@ -7252,7 +7471,8 @@ class PostgresBackendDriver {
       const contextForCallback = {
         user: this.user,
         driver: this,
-        data: this.data
+        data: this.data,
+        client: this.client
       };
       if (callbacks?.afterRead) {
         entity = await callbacks.afterRead({
@@ -7321,7 +7541,8 @@ class PostgresBackendDriver {
     const contextForCallback = {
       user: this.user,
       driver: this,
-      data: this.data
+      data: this.data,
+      client: this.client
     };
     let previousValuesForHistory;
     if (status === "existing" && entityId) {
@@ -7356,6 +7577,14 @@ class PostgresBackendDriver {
         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)) {
@@ -7461,7 +7690,8 @@ class PostgresBackendDriver {
     const contextForCallback = {
       user: this.user,
       driver: this,
-      data: this.data
+      data: this.data,
+      client: this.client
     };
     if (callbacks?.beforeDelete || propertyCallbacks?.beforeDelete) {
       if (callbacks?.beforeDelete) {
@@ -7788,6 +8018,7 @@ class AuthenticatedPostgresBackendDriver {
       txDelegate.entityService = txEntityService;
       txDelegate._deferNotifications = true;
       txDelegate._pendingNotifications = pendingNotifications;
+      txDelegate.client = this.delegate.client;
       return await operation(txDelegate);
     });
     for (const notification of pendingNotifications) {
@@ -8069,6 +8300,12 @@ const userIdentitiesRelations = relations(userIdentities, ({
     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));
@@ -8109,7 +8346,7 @@ const isIdProperty = (propName, prop, collection) => {
   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": {
@@ -8181,6 +8418,9 @@ const getDrizzleColumn = (propName, prop, collection, collections) => {
       } else {
         columnDefinition = `timestamp("${colName}", { withTimezone: true, mode: 'string' })`;
       }
+      if (dateProp.autoValue === "on_create" || dateProp.autoValue === "on_update") {
+        columnDefinition += `.default(sql\`now()\`)`;
+      }
       break;
     }
     case "map":
@@ -8213,7 +8453,7 @@ const getDrizzleColumn = (propName, prop, collection, collections) => {
       } 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;
@@ -8401,7 +8641,7 @@ const generateSchema = async (collections, stripPolicies = false) => {
     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(", ")}]);
@@ -8458,9 +8698,9 @@ const generateSchema = async (collections, stripPolicies = false) => {
       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}] })
@@ -8584,6 +8824,32 @@ const generateSchema = async (collections, stripPolicies = false) => {
           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`;