@rebasepro/server-postgresql 0.1.2 → 0.2.3

package/src/schema/generate-drizzle-schema-logic.ts

@@ -1,4 +1,4 @@
-import { EntityCollection, NumberProperty, Property, Relation, RelationProperty, SecurityOperation, SecurityRule, StringProperty, isPostgresCollection, DateProperty, ArrayProperty, MapProperty, ReferenceProperty } from "@rebasepro/types";
+import { EntityCollection, NumberProperty, Property, Relation, RelationProperty, SecurityOperation, SecurityRule, StringProperty, isPostgresCollection, DateProperty, ArrayProperty, MapProperty, ReferenceProperty, VectorProperty, BinaryProperty } from "@rebasepro/types";
 import { getPrimaryKeys } from "../services/entity-helpers";
 import { getEnumVarName, getTableName, getTableVarName, resolveCollectionRelations, findRelation } from "@rebasepro/common";
 import { toSnakeCase } from "@rebasepro/utils";
@@ -19,23 +19,23 @@ const resolveColumnName = (propName: string, prop?: Property | null): string =>
 
 const getPrimaryKeyProp = (collection: EntityCollection): { name: string, type: "string" | "number", isUuid: boolean } => {
     if (collection.properties) {
-        const idPropEntry = Object.entries(collection.properties).find(([_, prop]) => "isId" in (prop as object) && Boolean((prop as unknown as Record<string, unknown>).isId));
+        const idPropEntry = Object.entries(collection.properties).find(([_, prop]) => "isId" in (prop as unknown as object) && Boolean((prop as unknown as Record<string, unknown>).isId));
         if (idPropEntry) {
-            const prop = idPropEntry[1] as Property;
-            const isUuid = prop.type === "string" && "isId" in prop && (prop as StringProperty).isId === "uuid";
+            const prop = idPropEntry[1] as unknown as Property;
+            const isUuid = prop.type === "string" && "isId" in prop && (prop as unknown as StringProperty).isId === "uuid";
             return { name: idPropEntry[0],
 type: prop.type === "number" ? "number" : "string",
 isUuid };
         }
     }
     // Fallback
-    const idProp = collection.properties?.["id"] as Property | undefined;
+    const idProp = collection.properties?.["id"] as unknown as Property | undefined;
     if (idProp?.type === "number") {
         return { name: "id",
 type: "number",
 isUuid: false };
     }
-    const isUuid = idProp?.type === "string" && "isId" in idProp && (idProp as StringProperty).isId === "uuid";
+    const isUuid = idProp?.type === "string" && "isId" in idProp && (idProp as unknown as StringProperty).isId === "uuid";
     return { name: "id",
 type: "string",
 isUuid: isUuid ?? false };
@@ -53,17 +53,18 @@ const isIdProperty = (propName: string, prop: Property, collection: EntityCollec
     if ("isId" in prop && Boolean(prop.isId)) return true;
 
     // We only fallback to "id" if NO property is explicitly marked with `isId: true` or a generator string
-    const hasExplicitId = Object.values(collection.properties ?? {}).some(p => "isId" in (p as object) && Boolean((p as unknown as Record<string, unknown>).isId));
+    const hasExplicitId = Object.values(collection.properties ?? {}).some(p => "isId" in (p as unknown as object) && Boolean((p as unknown as Record<string, unknown>).isId));
     return !hasExplicitId && propName === "id";
 };
 
 const getDrizzleColumn = (propName: string, prop: Property, collection: EntityCollection, collections: EntityCollection[]): string | null => {
+
     const colName = resolveColumnName(propName, prop);
     let columnDefinition: string;
 
     switch (prop.type) {
         case "string": {
-            const stringProp = prop as StringProperty;
+            const stringProp = prop as unknown as StringProperty;
             if (stringProp.enum) {
                 const enumName = getEnumVarName(getTableName(collection), propName);
                 columnDefinition = `${enumName}("${colName}")`;
@@ -97,7 +98,7 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: EntityCo
             break;
         }
         case "number": {
-            const numProp = prop as NumberProperty;
+            const numProp = prop as unknown as NumberProperty;
             const isId = isIdProperty(propName, prop, collection);
 
             let baseType = (numProp.validation?.integer || isId) ? `integer("${colName}")` : `numeric("${colName}")`;
@@ -154,6 +155,15 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: EntityCo
             }
             break;
         }
+        case "vector": {
+            const vp = prop as VectorProperty;
+            columnDefinition = `vector("${colName}", { dimensions: ${vp.dimensions} })`;
+            break;
+        }
+        case "binary": {
+            columnDefinition = `customType({ dataType() { return 'bytea'; } })("${colName}")`;
+            break;
+        }
         case "relation": {
             const refProp = prop as RelationProperty;
             const resolvedRelations = resolveCollectionRelations(collection);
@@ -245,8 +255,8 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: EntityCo
  * The result is wrapped in a Drizzle sql`` template literal.
  */
 const resolveRawSql = (expression: string): string => {
-    // Replace {column_name} with ${table.column_name}
-    const resolved = expression.replace(/\{(\w+)\}/g, (_, col) => `\${table.${col}}`);
+    // Replace {column_name} with column_name directly (so Drizzle-kit can parse it as a static string)
+    const resolved = expression.replace(/\{(\w+)\}/g, (_, col) => col);
     return `sql\`${resolved}\``;
 };
 
@@ -271,7 +281,7 @@ const unwrapSql = (sqlExpr: string): string => {
 /**
  * Builds the USING clause for a policy based on shortcuts or raw SQL.
  */
-const buildUsingClause = (rule: SecurityRule): string | null => {
+const buildUsingClause = (rule: SecurityRule, collection: EntityCollection): string | null => {
     if (rule.using) {
         return resolveRawSql(rule.using);
     }
@@ -279,7 +289,9 @@ const buildUsingClause = (rule: SecurityRule): string | null => {
         return "sql`true`";
     }
     if (rule.ownerField) {
-        return `sql\`\${table.${rule.ownerField}} = auth.uid()\``;
+        const prop = collection.properties?.[rule.ownerField];
+        const colName = resolveColumnName(rule.ownerField, prop);
+        return `sql\`${colName} = auth.uid()\``;
     }
     return null;
 };
@@ -288,12 +300,12 @@ const buildUsingClause = (rule: SecurityRule): string | null => {
  * Builds the WITH CHECK clause for a policy based on shortcuts or raw SQL.
  * Falls back to the USING clause if not explicitly provided.
  */
-const buildWithCheckClause = (rule: SecurityRule): string | null => {
+const buildWithCheckClause = (rule: SecurityRule, collection: EntityCollection): string | null => {
     if (rule.withCheck) {
         return resolveRawSql(rule.withCheck);
     }
     // For insert/update/all, fall back to using clause if withCheck not specified
-    return buildUsingClause(rule);
+    return buildUsingClause(rule, collection);
 };
 
 /**
@@ -324,7 +336,8 @@ const getPolicyNameHash = (rule: SecurityRule): string => {
  * - operations[] array: generates one policy per operation
  * - Combinations: roles + ownerField, roles + raw SQL, etc.
  */
-const generatePolicyCode = (tableName: string, rule: SecurityRule, index: number): string => {
+const generatePolicyCode = (collection: EntityCollection, rule: SecurityRule, index: number): string => {
+    const tableName = getTableName(collection);
     // Resolve operations: operations[] takes precedence over operation (singular)
     const ops: SecurityOperation[] = rule.operations && rule.operations.length > 0
         ? rule.operations
@@ -338,14 +351,14 @@ const generatePolicyCode = (tableName: string, rule: SecurityRule, index: number
             ? (ops.length > 1 ? `${rule.name}_${op}` : rule.name)
             : `${tableName}_${op}_${ruleHash}${ops.length > 1 ? `_${opIdx}` : ""}`;
 
-        return generateSinglePolicyCode(tableName, rule, op, policyName);
+        return generateSinglePolicyCode(collection, rule, op, policyName);
     }).join("");
 };
 
 /**
  * Generates a single pgPolicy() call for one specific operation.
  */
-const generateSinglePolicyCode = (tableName: string, rule: SecurityRule, operation: SecurityOperation, policyName: string): string => {
+const generateSinglePolicyCode = (collection: EntityCollection, rule: SecurityRule, operation: SecurityOperation, policyName: string): string => {
     const mode = rule.mode ?? "permissive";
     const roles = rule.roles ? [...rule.roles].sort() : undefined;
 
@@ -356,8 +369,8 @@ const generateSinglePolicyCode = (tableName: string, rule: SecurityRule, operati
     const needsUsing = operation !== "insert";
     const needsWithCheck = operation !== "select" && operation !== "delete";
 
-    let usingClause = needsUsing ? buildUsingClause(rule) : null;
-    let withCheckClause = needsWithCheck ? buildWithCheckClause(rule) : null;
+    let usingClause = needsUsing ? buildUsingClause(rule, collection) : null;
+    let withCheckClause = needsWithCheck ? buildWithCheckClause(rule, collection) : null;
 
     // If roles are specified, wrap existing clauses with role check,
     // or generate a roles-only clause.
@@ -485,18 +498,41 @@ export const generateSchema = async (collections: EntityCollection[], stripPolic
         )
     );
 
-    const hasJson = collections.some(c =>
+    const hasVector = collections.some(c =>
         c.properties && Object.values(c.properties).some(
-            (p: Property) => (p.type === "map" || p.type === "array") && (p as unknown as Record<string, unknown>).columnType === "json"
+            (p: Property) => p.type === "vector"
+        )
+    );
+
+    const hasBinary = collections.some(c =>
+        c.properties && Object.values(c.properties).some(
+            (p: Property) => p.type === "binary"
         )
     );
 
     // Always import pgPolicy and sql — RLS is enabled on every table (secure by default)
     const pgCoreImports = ["primaryKey", "pgTable", "integer", "varchar", "text", "char", "boolean", "timestamp", "date", "time", "jsonb", "json", "pgEnum", "numeric", "real", "doublePrecision", "bigint", "serial", "bigserial", "pgPolicy"];
     if (hasUuid) pgCoreImports.push("uuid");
+    if (hasVector) pgCoreImports.push("vector");
+    if (hasBinary) pgCoreImports.push("customType");
+
+    const uniqueSchemas = Array.from(new Set(
+        collections.map(c => isPostgresCollection(c) ? c.schema : undefined).filter(Boolean)
+    ));
+    if (uniqueSchemas.length > 0) {
+        pgCoreImports.push("pgSchema");
+    }
+
     schemaContent += `import { ${pgCoreImports.join(", ")} } from 'drizzle-orm/pg-core';\n`;
     schemaContent += "import { relations as drizzleRelations, sql } from 'drizzle-orm';\n\n";
 
+    uniqueSchemas.forEach(schema => {
+        schemaContent += `export const ${schema}Schema = pgSchema("${schema}");\n`;
+    });
+    if (uniqueSchemas.length > 0) {
+        schemaContent += "\n";
+    }
+
     const exportedTableVars: string[] = [];
     const exportedEnumVars: string[] = [];
     const exportedRelationVars: string[] = [];
@@ -512,6 +548,7 @@ export const generateSchema = async (collections: EntityCollection[], stripPolic
     collections.forEach(collection => {
         const collectionPath = getTableName(collection);
         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}_${resolveColumnName(propName, prop)}`;
@@ -564,6 +601,9 @@ export const generateSchema = async (collections: EntityCollection[], stripPolic
         const tableVarName = getTableVarName(tableName);
         if (isJunction && relation && sourceCollection && relation.through) {
             const targetCollection = relation.target();
+            const schema = (isPostgresCollection(targetCollection) ? targetCollection.schema : undefined) || (isPostgresCollection(sourceCollection) ? sourceCollection.schema : undefined);
+            const tableCreator = schema ? `${schema}Schema.table` : "pgTable";
+            const baseTableName = tableName.includes(".") ? tableName.split(".").pop()! : tableName;
             const {
                 sourceColumn,
                 targetColumn
@@ -577,14 +617,17 @@ export const generateSchema = async (collections: EntityCollection[], stripPolic
             const sourceId = getPrimaryKeyName(sourceCollection);
             const targetId = getPrimaryKeyName(targetCollection);
 
-            schemaContent += `export const ${tableVarName} = pgTable(\"${tableName}\", {\n`;
+            schemaContent += `export const ${tableVarName} = ${tableCreator}(\"${baseTableName}\", {\n`;
             schemaContent += `    ${sourceColumn}: ${sourceColType}(\"${sourceColumn}\").notNull().references(() => ${getTableVarName(getTableName(sourceCollection))}.${sourceId}, ${refOptions}),\n`;
             schemaContent += `    ${targetColumn}: ${targetColType}(\"${targetColumn}\").notNull().references(() => ${getTableVarName(getTableName(targetCollection))}.${targetId}, ${refOptions}),\n`;
             schemaContent += "}, (table) => ({\n";
             schemaContent += `    pk: primaryKey({ columns: [table.${sourceColumn}, table.${targetColumn}] })\n`;
             schemaContent += "}));\n\n";
         } else if (!isJunction) {
-            schemaContent += `export const ${tableVarName} = pgTable(\"${tableName}\", {\n`;
+            const schema = isPostgresCollection(collection) ? collection.schema : undefined;
+            const tableCreator = schema ? `${schema}Schema.table` : "pgTable";
+            const baseTableName = tableName.includes(".") ? tableName.split(".").pop()! : tableName;
+            schemaContent += `export const ${tableVarName} = ${tableCreator}(\"${baseTableName}\", {\n`;
             const columns = new Set<string>();
             Object.entries(collection.properties ?? {}).forEach(([propName, prop]) => {
                 const columnString = getDrizzleColumn(propName, prop as Property, collection, collections);
@@ -605,7 +648,7 @@ export const generateSchema = async (collections: EntityCollection[], stripPolic
             if (!stripPolicies && securityRules && securityRules.length > 0) {
                 schemaContent += "\n}, (table) => ([\n";
                 securityRules.forEach((rule: SecurityRule, idx: number) => {
-                    schemaContent += generatePolicyCode(tableName, rule, idx);
+                    schemaContent += generatePolicyCode(collection, rule, idx);
                 });
                 schemaContent += "])).enableRLS();\n\n";
             } else {
@@ -666,8 +709,12 @@ export const generateSchema = async (collections: EntityCollection[], stripPolic
                 tableRelations.push(`    "${relation.through.sourceColumn}": one(${sourceTableVar}, {\n        fields: [${tableVarName}.${relation.through.sourceColumn}],\n        references: [${sourceTableVar}.${sourceId}],\n        relationName: \"${owningRelationName}\"\n    })`);
 
                 // Target side one(): pairs with inverse table's many(junctionTable, { relationName })
-                const targetRelName = inverseRelationName ?? owningRelationName;
-                tableRelations.push(`    "${relation.through.targetColumn}": one(${targetTableVar}, {\n        fields: [${tableVarName}.${relation.through.targetColumn}],\n        references: [${targetTableVar}.${targetId}],\n        relationName: \"${targetRelName}\"\n    })`);
+                // Always emit a relationName to avoid collisions with the source-side's owningRelationName.
+                // When no inverse relation exists on the target collection, synthesize a unique name.
+                const targetRelationName = inverseRelationName
+                    ? inverseRelationName
+                    : `${tableName}_${relation.through.targetColumn}`;
+                tableRelations.push(`    "${relation.through.targetColumn}": one(${targetTableVar}, {\n        fields: [${tableVarName}.${relation.through.targetColumn}],\n        references: [${targetTableVar}.${targetId}],\n        relationName: "${targetRelationName}"\n    })`);
             }
         } else {
             const resolvedRelations = resolveCollectionRelations(collection);

package/src/schema/generate-drizzle-schema.ts

@@ -5,6 +5,7 @@ import { pathToFileURL } from "url";
 import chokidar from "chokidar";
 import { generateSchema } from "./generate-drizzle-schema-logic";
 import { EntityCollection } from "@rebasepro/types";
+import { defaultUsersCollection } from "./default-collections";
 
 // --- Helper Functions ---
 
@@ -84,11 +85,20 @@ const runGeneration = async (collectionsFilePath?: string, outputPath?: string)
             collections = imported.backendCollections || imported.collections;
         }
 
-        if (!collections || !Array.isArray(collections) || collections.length === 0) {
-            console.error("Error: Could not find collections array or failed to load directory.");
-            return;
+        // If collections directory is empty but exists, or failed to find any, we still want to inject defaults
+        if (!collections || !Array.isArray(collections)) {
+            collections = [];
+        }
+
+        // Inject default collections if not overridden by the developer
+        const hasUsersCollection = collections.some(c => c.slug === "users");
+        if (!hasUsersCollection) {
+            collections.push(defaultUsersCollection);
         }
 
+        // Sort collections by slug alphabetically to ensure deterministic schema generation
+        collections.sort((a, b) => a.slug.localeCompare(b.slug));
+
         const schemaContent = await generateSchema(collections);
 
         if (outputPath) {

package/src/schema/introspect-db-inference.ts

@@ -17,8 +17,8 @@ export function inferPropertyFromData(
     sampleValues: unknown[],
     isPk: boolean
 ): InferenceResult {
-    let result: InferenceResult = {};
-    let extraLines: string[] = [];
+    const result: InferenceResult = {};
+    const extraLines: string[] = [];
 
     // Filter out null/undefined for analysis
     const validValues = sampleValues.filter(v => v !== null && v !== undefined && v !== "");
@@ -84,7 +84,7 @@ export function inferPropertyFromData(
             let allNumbers = true;
             let allStrings = true;
             for (const v of validValues) {
-                let parsed = typeof v === "string" ? JSON.parse(v) : v;
+                const parsed = typeof v === "string" ? JSON.parse(v) : v;
                 for (const item of parsed) {
                     if (typeof item !== "number") allNumbers = false;
                     if (typeof item !== "string") allStrings = false;
@@ -99,7 +99,7 @@ export function inferPropertyFromData(
             if (allObjects && validValues.length > 0) {
                 const schema: Record<string, string> = {};
                 for (const v of validValues) {
-                    let parsed = typeof v === "string" ? JSON.parse(v) : v;
+                    const parsed = typeof v === "string" ? JSON.parse(v) : v;
                     for (const [k, val] of Object.entries(parsed)) {
                         if (val === null || val === undefined) continue;
                         const type = typeof val;
@@ -221,7 +221,7 @@ export function inferPropertyFromData(
             if (hasFileExtension) {
                 const firstVal = validValues[0] as string;
                 const lastSlash = firstVal.lastIndexOf('/');
-                let inferredStoragePath = lastSlash > 0 ? firstVal.substring(0, lastSlash) : "files";
+                const inferredStoragePath = lastSlash > 0 ? firstVal.substring(0, lastSlash) : "files";
                 extraLines.push(`            storage: {\n                storagePath: "${inferredStoragePath}"\n            }`);
             } else if (isUrl) {
                 if (isMedia) {

package/src/schema/introspect-db-logic.ts

@@ -21,6 +21,7 @@ export interface TableColumn {
     udt_name: string;
     is_nullable: string;
     column_default: string | null;
+    atttypmod: number | null;
 }
 
 export interface EnumValue {
@@ -187,7 +188,7 @@ export function mapPgType(dataType: string): string {
     if (dt === "json" || dt === "jsonb") return "map";
 
     // Binary
-    if (dt === "bytea") return "string";
+    if (dt === "bytea") return "binary";
 
     // Network types
     if (dt === "inet" || dt === "cidr" || dt === "macaddr" || dt === "macaddr8") return "string";
@@ -548,8 +549,9 @@ export function generateCollectionFile(
         // Check if this column uses a PostgreSQL enum type
         const colEnumValues = enumMap.get(col.udt_name);
         const isEnumColumn = col.data_type === "USER-DEFINED" && colEnumValues !== undefined;
+        const isVectorColumn = col.udt_name === "vector";
 
-        const propType = isEnumColumn ? "string" : mapPgType(col.data_type);
+        const propType = isEnumColumn ? "string" : (isVectorColumn ? "vector" : mapPgType(col.data_type));
         let extra = "";
 
         const colNameLower = col.column_name.toLowerCase();
@@ -633,6 +635,11 @@ export function generateCollectionFile(
             }
         }
 
+        if (finalPropType === "vector") {
+            const dims = col.atttypmod && col.atttypmod > 0 ? col.atttypmod : 1536;
+            extra += `\n            dimensions: ${dims},`;
+        }
+
         if (col.is_nullable === "NO" && !meta.pks.includes(col.column_name) && !col.column_default) {
             if (extra.includes("validation: {")) {
                 extra = extra.replace("validation: {", "validation: {\n                required: true,");

package/src/schema/introspect-db.ts

@@ -99,9 +99,20 @@ async function main() {
 
         // 2. Get Columns
         const { rows: columns } = await client.query<TableColumn>(`
-            SELECT table_name, column_name, data_type, udt_name, is_nullable, column_default
-            FROM information_schema.columns
-            WHERE table_schema = $1
+            SELECT 
+                c.table_name, 
+                c.column_name, 
+                c.data_type, 
+                c.udt_name, 
+                c.is_nullable, 
+                c.column_default,
+                (SELECT a.atttypmod FROM pg_attribute a 
+                 JOIN pg_class pc ON a.attrelid = pc.oid 
+                 WHERE pc.relname = c.table_name 
+                   AND a.attname = c.column_name 
+                   AND pc.relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = c.table_schema)) as atttypmod
+            FROM information_schema.columns c
+            WHERE c.table_schema = $1
         `, [pgSchema]);
 
         // 2b. Get Enum Types and their values

package/src/services/EntityFetchService.ts

@@ -606,7 +606,7 @@ export class EntityFetchService {
                 const row = await qb.findFirst({
                     where: eq(idField, parsedId),
                     with: withConfig
-                } as unknown as Parameters<NonNullable<typeof qb>["findFirst"]>[0]);
+                } as Parameters<NonNullable<typeof qb>["findFirst"]>[0]);
 
                 if (!row) return undefined;
 
@@ -729,7 +729,7 @@ export class EntityFetchService {
                 );
 
 
-                const results = await qb.findMany(queryOpts as unknown as Parameters<NonNullable<typeof qb>["findMany"]>[0]);
+                const results = await qb.findMany(queryOpts as Parameters<NonNullable<typeof qb>["findMany"]>[0]);
 
                 const entities = (results as Record<string, unknown>[]).map(row =>
                     this.drizzleResultToEntity<M>(row, collection, collectionPath, idInfo, options.databaseId, idInfoArray)
@@ -1192,7 +1192,7 @@ export class EntityFetchService {
                 );
 
 
-                const results = await qb.findMany(queryOpts as unknown as Parameters<NonNullable<typeof qb>["findMany"]>[0]);
+                const results = await qb.findMany(queryOpts as Parameters<NonNullable<typeof qb>["findMany"]>[0]);
 
                 const restRows = (results as Record<string, unknown>[]).map(row =>
                     this.drizzleResultToRestRow(row, collection, idInfo, idInfoArray)
@@ -1306,7 +1306,7 @@ export class EntityFetchService {
                 const row = await qb.findFirst({
                     where: eq(idField, parsedId),
                     ...(withConfig ? { with: withConfig } : {})
-                } as unknown as Parameters<NonNullable<typeof qb>["findFirst"]>[0]);
+                } as Parameters<NonNullable<typeof qb>["findFirst"]>[0]);
 
                 if (!row) return null;
 
@@ -1516,7 +1516,7 @@ export class EntityFetchService {
             }
 
 
-            const results = await queryTarget.findMany(queryOpts as unknown as Parameters<NonNullable<typeof queryTarget>["findMany"]>[0]);
+            const results = await queryTarget.findMany(queryOpts as Parameters<NonNullable<typeof queryTarget>["findMany"]>[0]);
 
             // Flatten the nested Drizzle results into REST format
             return results.map((row: Record<string, unknown>) => {

package/src/services/RelationService.ts

@@ -1159,7 +1159,7 @@ export class RelationService {
                 if (parentFKValue !== null && parentFKValue !== undefined) {
                     await tx.update(targetTable)
                         .set({ [targetFKColName]: null })
-                        .where(eq(targetFKCol, parentFKValue as unknown as string));
+                        .where(eq(targetFKCol, String(parentFKValue)));
                 }
                 continue;
             }
@@ -1172,7 +1172,7 @@ export class RelationService {
             if (parentFKValue !== null && parentFKValue !== undefined) {
                 await tx.update(targetTable)
                     .set({ [targetFKColName]: null })
-                    .where(eq(targetFKCol, parentFKValue as unknown as string));
+                    .where(eq(targetFKCol, String(parentFKValue)));
             } else {
                 console.warn(`Cannot set joinPath relation '${relation.relationName}' because parent FK value is null/undefined`);
                 continue;

package/src/services/entity-helpers.ts

@@ -13,7 +13,7 @@ import { getTableName } from "@rebasepro/common";
 
 /**
  * Interface for Drizzle column metadata introspection.
- * Replaces unsafe `as unknown as Record<string, unknown>` double-cast chains.
+ * Replaces unsafe `as Record<string, unknown>` double-cast chains.
  */
 export interface DrizzleColumnMeta {
     columnType?: string;