@rebasepro/server-postgresql 0.1.0 → 0.2.1

package/src/schema/doctor-cli.ts

@@ -5,14 +5,17 @@
  */
 import path from "path";
 import chalk from "chalk";
+import fs from "fs";
 import { runDoctor } from "./doctor";
 
 async function main() {
     const collectionsArg = process.argv.find((a) => a.startsWith("--collections="));
     const schemaArg = process.argv.find((a) => a.startsWith("--schema="));
+    const sdkArg = process.argv.find((a) => a.startsWith("--sdk="));
 
-    const collectionsPath = collectionsArg?.split("=")[1] ?? path.join("..", "shared", "collections");
+    const collectionsPath = collectionsArg?.split("=")[1] ?? path.join("..", "config", "collections");
     const schemaPath = schemaArg?.split("=")[1] ?? path.join("src", "schema.generated.ts");
+    const sdkPath = sdkArg?.split("=")[1] ?? path.join("..", "generated", "sdk", "database.types.ts");
 
     // Load .env
     try {
@@ -32,6 +35,7 @@ async function main() {
     const report = await runDoctor({
         collectionsPath: path.resolve(process.cwd(), collectionsPath),
         schemaPath: path.resolve(process.cwd(), schemaPath),
+        sdkPath: path.resolve(process.cwd(), sdkPath),
         databaseUrl: databaseUrl ?? undefined
     });
 

package/src/schema/doctor.ts

@@ -14,6 +14,7 @@ import { pathToFileURL } from "url";
 import chalk from "chalk";
 import { EntityCollection, isPostgresCollection, Property, NumberProperty, StringProperty, DateProperty, ArrayProperty, MapProperty, RelationProperty } from "@rebasepro/types";
 import { generateSchema } from "./generate-drizzle-schema-logic";
+import { generateTypedefs } from "@rebasepro/sdk-generator";
 import { getTableName, resolveCollectionRelations, findRelation } from "@rebasepro/common";
 import { toSnakeCase } from "@rebasepro/utils";
 
@@ -35,7 +36,7 @@ export type IssueSeverity = "error" | "warning" | "info";
 
 export interface DoctorIssue {
     severity: IssueSeverity;
-    category: "missing_table" | "missing_column" | "type_mismatch" | "missing_constraint" | "schema_stale" | "missing_enum" | "enum_value_mismatch" | "missing_foreign_key";
+    category: "missing_table" | "missing_column" | "type_mismatch" | "missing_constraint" | "schema_stale" | "missing_enum" | "enum_value_mismatch" | "missing_foreign_key" | "sdk_stale";
     table?: string;
     column?: string;
     expected?: string;
@@ -46,6 +47,7 @@ export interface DoctorIssue {
 
 export interface DoctorReport {
     collectionsToSchema: { passed: boolean; issues: DoctorIssue[] };
+    collectionsToSdk: { passed: boolean; issues: DoctorIssue[] };
     schemaToDatabase: { passed: boolean; issues: DoctorIssue[] };
     summary: { passed: number; warnings: number; errors: number };
 }
@@ -92,6 +94,10 @@ export function getExpectedColumnType(prop: Property): string | null {
             return null; // FK columns are derived from the relation, not from the property
         case "reference":
             return "character varying"; // References default to varchar FK
+        case "vector":
+            return "USER-DEFINED";
+        case "binary":
+            return "bytea";
         default:
             return null;
     }
@@ -139,6 +145,9 @@ export async function loadCollections(collectionsPath: string): Promise<EntityCo
         }
     }
 
+    // Sort collections by slug alphabetically to ensure deterministic comparison
+    collections.sort((a, b) => a.slug.localeCompare(b.slug));
+
     return collections;
 }
 
@@ -203,6 +212,56 @@ issues };
 issues };
 }
 
+export async function checkCollectionsVsSdk(
+    collections: EntityCollection[],
+    sdkFilePath: string
+): Promise<{ passed: boolean; issues: DoctorIssue[] }> {
+    const issues: DoctorIssue[] = [];
+
+    // Check if SDK file exists
+    if (!fs.existsSync(sdkFilePath)) {
+        issues.push({
+            severity: "warning",
+            category: "sdk_stale",
+            message: `Generated SDK typedefs file does not exist at "${sdkFilePath}".`,
+            fix: "Run `rebase generate-sdk`"
+        });
+        return { passed: false, issues };
+    }
+
+    try {
+        const expectedSdk = generateTypedefs(collections);
+        const actualSdk = await fsPromises.readFile(sdkFilePath, "utf-8");
+
+        // Normalize whitespace for comparison
+        const normalize = (s: string) =>
+            s
+                .replace(/\/\/.*$/gm, "") // strip single-line comments
+                .replace(/\/\*[\s\S]*?\*\//g, "") // strip multi-line comments
+                .replace(/\s+/g, " ")
+                .trim();
+
+        if (normalize(expectedSdk) !== normalize(actualSdk)) {
+            issues.push({
+                severity: "warning",
+                category: "sdk_stale",
+                message: "Generated SDK types are out of date — collection definitions have changed since last SDK generation.",
+                fix: "Run `rebase generate-sdk`"
+            });
+        }
+    } catch (err: unknown) {
+        const message = err instanceof Error ? err.message : String(err);
+        issues.push({
+            severity: "warning",
+            category: "sdk_stale",
+            message: `Could not regenerate SDK types for comparison: ${message}`,
+            fix: "Run `rebase generate-sdk` to verify"
+        });
+    }
+
+    return { passed: issues.length === 0, issues };
+}
+
 // ── Phase 2: Collections ↔ Database ──────────────────────────────────────
 
 interface DbColumn {
@@ -383,15 +442,19 @@ export async function checkCollectionsVsDatabase(
                 const expectedType = getExpectedColumnType(prop);
                 if (expectedType) {
                     const actualType = dbCol.data_type;
-                    if (actualType !== expectedType) {
+                    let isMismatch = actualType !== expectedType;
+                    if (prop.type === "vector" && dbCol.udt_name !== "vector") {
+                        isMismatch = true;
+                    }
+                    if (isMismatch) {
                         issues.push({
                             severity: "warning",
                             category: "type_mismatch",
                             table: tableName,
                             column: colName,
-                            expected: expectedType,
-                            actual: actualType,
-                            message: `Column "${colName}" in table "${tableName}": expected type "${expectedType}" but found "${actualType}".`,
+                            expected: prop.type === "vector" ? "vector" : expectedType,
+                            actual: dbCol.udt_name === "vector" ? "vector" : actualType,
+                            message: `Column "${colName}" in table "${tableName}": expected type "${prop.type === "vector" ? "vector" : expectedType}" but found "${dbCol.udt_name === "vector" ? "vector" : actualType}".`,
                             fix: "Review collection property type or run a migration"
                         });
                     }
@@ -489,6 +552,13 @@ export function renderReport(report: DoctorReport): void {
         report.schemaToDatabase.issues
     );
 
+    // Phase 3
+    renderPhase(
+        "Collections → SDK Types",
+        report.collectionsToSdk.passed,
+        report.collectionsToSdk.issues
+    );
+
     // Summary
     console.log(chalk.gray("  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"));
     const { passed, warnings, errors } = report.summary;
@@ -554,7 +624,8 @@ function formatCategory(cat: DoctorIssue["category"]): string {
         schema_stale: "Stale Schema",
         missing_enum: "Missing Enum",
         enum_value_mismatch: "Enum Value Mismatch",
-        missing_foreign_key: "Missing Foreign Key"
+        missing_foreign_key: "Missing Foreign Key",
+        sdk_stale: "Stale SDK Types"
     };
     return labels[cat];
 }
@@ -564,6 +635,7 @@ function formatCategory(cat: DoctorIssue["category"]): string {
 export async function runDoctor(options: {
     collectionsPath: string;
     schemaPath: string;
+    sdkPath: string;
     databaseUrl?: string;
 }): Promise<DoctorReport> {
     console.log("");
@@ -591,14 +663,19 @@ issues: [] };
         console.log(chalk.gray("    Set DATABASE_URL in your .env to enable full drift detection."));
     }
 
-    const allIssues = [...collectionsToSchema.issues, ...schemaToDatabase.issues];
+    // Phase 3: Collections ↔ SDK Types
+    console.log(chalk.gray("  Checking Collections → SDK Types..."));
+    const collectionsToSdk = await checkCollectionsVsSdk(collections, options.sdkPath);
+
+    const allIssues = [...collectionsToSchema.issues, ...schemaToDatabase.issues, ...collectionsToSdk.issues];
     const summary = {
-        passed: [collectionsToSchema, schemaToDatabase].filter((p) => p.passed).length,
+        passed: [collectionsToSchema, schemaToDatabase, collectionsToSdk].filter((p) => p.passed).length,
         warnings: allIssues.filter((i) => i.severity === "warning").length,
         errors: allIssues.filter((i) => i.severity === "error").length
     };
 
     const report: DoctorReport = { collectionsToSchema,
+collectionsToSdk,
 schemaToDatabase,
 summary };
     renderReport(report);

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>) => {