dzql 0.6.18 → 0.6.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dzql",
-  "version": "0.6.18",
+  "version": "0.6.20",
   "description": "Database-first real-time framework with TypeScript support",
   "repository": {
     "type": "git",

package/src/cli/codegen/sql.ts

@@ -583,6 +583,31 @@ export function generateGetFunction(name: string, entityIR: EntityIR): string {
   // Build SELECT expression excluding hidden fields
   const selectExpr = buildVisibleJsonb(name, entityIR.columns, hidden);
 
+  // FK expansion for GET (only direct FKs where {key}_id column exists)
+  // Reverse FK expansion (one-to-many) should be handled by subscribables for complex queries
+  const includes: Record<string, IncludeIR> = entityIR.includes || {};
+  const includeKeys = Object.keys(includes);
+  const fkExpansion = includeKeys.map(key => {
+    const config: IncludeIR = includes[key];
+    const targetEntity = config.entity;
+    const fkField = `${key}_id`; // Convention: author -> author_id
+
+    // Only expand direct FKs (key_id column exists on this entity)
+    const hasFkColumn = entityIR.columns.some((c: ColumnInfo) => c.name === fkField);
+
+    if (hasFkColumn) {
+      // Direct FK: single object expansion (e.g., author_id -> author object)
+      return `
+  -- FK: Add ${key} to result (from ${fkField})
+  IF (v_result->>'${fkField}') IS NOT NULL THEN
+    v_result := v_result || jsonb_build_object('${key}',
+      (SELECT to_jsonb(t.*) FROM ${targetEntity} t WHERE t.id = (v_result->>'${fkField}')::int));
+  END IF;`;
+    }
+    // Skip reverse FKs - use subscribables for complex document graphs
+    return '';
+  }).filter(s => s).join('\n');
+
   // M2M expansion for GET
   const m2m: Record<string, ManyToManyIR> = entityIR.manyToMany || {};
   const m2mKeys = Object.keys(m2m);
@@ -625,6 +650,7 @@ BEGIN
   IF v_result IS NULL THEN
     RETURN NULL;
   END IF;
+${fkExpansion}
 ${m2mExpansion}
 
   RETURN v_result;

package/src/cli/codegen/types.ts

@@ -133,14 +133,18 @@ export type FilterValue<T> = T | FilterOperators<T>;
 
         // Add includes as optional fields
         if (sub.includes) {
+          const rootEntityIR = entities[rootEntity];
+          const rootColumns = new Set(rootEntityIR.columns.map(c => c.name));
+
           for (const [includeKey, includeIR] of Object.entries(sub.includes)) {
             const includeEntity = includeIR.entity;
             const includeEntityPascal = toPascalCase(includeEntity);
 
-            // Determine if it's an array (one-to-many) or single (many-to-one)
-            // For now, assume arrays unless the include key matches a FK pattern
-            const isArray = !includeKey.endsWith('_id') && includeKey !== rootEntity;
-            const includeType = isArray ? `${includeEntityPascal}[]` : includeEntityPascal;
+            // Determine if it's many-to-one (singular) or one-to-many (array)
+            // If root entity has a column `{includeKey}_id`, it's many-to-one
+            const fkColumn = `${includeKey}_id`;
+            const isManyToOne = rootColumns.has(fkColumn);
+            const includeType = isManyToOne ? includeEntityPascal : `${includeEntityPascal}[]`;
 
             output += `  ${includeKey}?: ${includeType};\n`;
           }