dzql 0.5.33 → 0.6.1

package/src/cli/codegen/subscribable_store.ts

@@ -0,0 +1,184 @@
+import { Manifest } from "./manifest.js";
+import { SubscribableIR, IncludeIR } from "../../shared/ir.js";
+
+function toPascalCase(str: string): string {
+  return str.replace(/(^|_)([a-z])/g, (g) => g[g.length - 1].toUpperCase());
+}
+
+export function generateSubscribableStore(manifest: Manifest, subName: string): string {
+  const sub = manifest.subscribables[subName];
+  if (!sub) {
+    throw new Error(`Subscribable '${subName}' not found in manifest.`);
+  }
+
+  const pascalName = toPascalCase(subName);
+
+  // Generate params interface
+  const paramEntries = Object.entries(sub.params);
+  const paramsInterface = paramEntries.length > 0
+    ? paramEntries.map(([name, pgType]) => {
+        let tsType = 'unknown';
+        const type = pgType.toLowerCase();
+        if (type.includes('int')) tsType = 'number';
+        else if (type.includes('text') || type.includes('varchar')) tsType = 'string';
+        else if (type.includes('bool')) tsType = 'boolean';
+        return `  ${name}: ${tsType};`;
+      }).join('\n')
+    : '  [key: string]: unknown;';
+
+  // Helper to generate patch cases recursively
+  const generatePatchCases = (): string => {
+    const cases: string[] = [];
+
+    // 1. Root Entity
+    cases.push(
+      `      case '${sub.root.entity}':\n` +
+      `        if (event.op === 'update' && doc.${sub.root.entity}) {\n` +
+      `          Object.assign(doc.${sub.root.entity}, event.data);\n` +
+      `        }\n` +
+      `        break;`
+    );
+
+    // 2. Recursive Includes
+    const traverse = (includes: Record<string, IncludeIR>, pathStack: string[]) => {
+      for (const [key, include] of Object.entries(includes)) {
+        const entityName = include.entity;
+
+        if (pathStack.length === 0) {
+          // Level 1
+          cases.push(
+            `      case '${entityName}':\n` +
+            `        handleArrayPatch(doc.${key}, event);\n` +
+            `        break;`
+          );
+        } else {
+          // Level 2+
+          const level1Rel = pathStack[0];
+          const singularParent = level1Rel.endsWith('s') ? level1Rel.slice(0, -1) : level1Rel;
+          const fkField = `${singularParent}_id`;
+
+          cases.push(
+            `      case '${entityName}':\n` +
+            `        if (event.data && event.data.${fkField}) {\n` +
+            `          const parent = doc.${level1Rel}?.find((p: { id: number }) => p.id === event.data.${fkField});\n` +
+            `          if (parent && parent.${key}) {\n` +
+            `            handleArrayPatch(parent.${key}, event);\n` +
+            `          }\n` +
+            `        }\n` +
+            `        break;`
+          );
+        }
+
+        if (include.includes) {
+          traverse(include.includes, [...pathStack, key]);
+        }
+      }
+    };
+
+    traverse(sub.includes, []);
+    return cases.join('\n');
+  };
+
+  const patchCases = generatePatchCases();
+
+  return `// Generated by TZQL Compiler v${manifest.version}
+// Do not edit this file directly.
+
+import { defineStore } from 'pinia';
+import { ref, type Ref } from 'vue';
+import { ws } from '../index.js';
+
+/** Parameters for ${subName} subscription */
+export interface ${pascalName}Params {
+${paramsInterface}
+}
+
+/** Event from server for patching */
+export interface PatchEvent {
+  table: string;
+  op: 'insert' | 'update' | 'delete';
+  pk: { id: number };
+  data: Record<string, unknown> | null;
+}
+
+/** Document wrapper with loading state */
+export interface DocumentWrapper<T> {
+  data: T;
+  loading: boolean;
+  ready: Promise<void>;
+}
+
+export const use${pascalName}Store = defineStore('sub-${subName}', () => {
+  const documents: Ref<Record<string, DocumentWrapper<Record<string, unknown>>>> = ref({});
+  const unsubscribers = new Map<string, () => void>();
+
+  async function bind(params: ${pascalName}Params): Promise<DocumentWrapper<Record<string, unknown>>> {
+    const key = JSON.stringify(params);
+
+    if (documents.value[key]) {
+      const existing = documents.value[key];
+      if (existing.loading) {
+        await existing.ready;
+      }
+      return existing;
+    }
+
+    let resolveReady!: () => void;
+    const ready = new Promise<void>((resolve) => { resolveReady = resolve; });
+
+    documents.value[key] = { data: {}, loading: true, ready };
+    let isFirst = true;
+
+    const unsubscribe = await ws.api.subscribe_${subName}(params, (eventData: unknown) => {
+      if (isFirst) {
+        // Initial data - merge into existing object to preserve reactivity
+        Object.assign(documents.value[key].data, eventData as Record<string, unknown>);
+        documents.value[key].loading = false;
+        isFirst = false;
+        resolveReady();
+      } else {
+        // Patch event
+        applyPatch(documents.value[key].data, eventData as PatchEvent);
+      }
+    });
+
+    unsubscribers.set(key, unsubscribe as () => void);
+    await ready;
+    return documents.value[key];
+  }
+
+  function unbind(params: ${pascalName}Params): void {
+    const key = JSON.stringify(params);
+    const unsubscribe = unsubscribers.get(key);
+    if (unsubscribe) {
+      unsubscribe();
+      unsubscribers.delete(key);
+      delete documents.value[key];
+    }
+  }
+
+  function applyPatch(doc: Record<string, unknown>, event: PatchEvent): void {
+    if (!doc) return;
+    switch (event.table) {
+${patchCases}
+    }
+  }
+
+  function handleArrayPatch(arr: unknown[] | undefined, event: PatchEvent): void {
+    if (!arr || !Array.isArray(arr)) return;
+    const pkValue = event.pk?.id;
+    const idx = arr.findIndex((i: unknown) => (i as { id: number }).id === pkValue);
+
+    if (event.op === 'insert') {
+      if (idx === -1 && event.data) arr.push(event.data);
+    } else if (event.op === 'update') {
+      if (idx !== -1 && event.data) Object.assign(arr[idx] as object, event.data);
+    } else if (event.op === 'delete') {
+      if (idx !== -1) arr.splice(idx, 1);
+    }
+  }
+
+  return { bind, unbind, documents };
+});
+`;
+}

package/src/cli/codegen/types.ts

@@ -0,0 +1,142 @@
+import { EntityIR, SubscribableIR } from "../../shared/ir.js";
+
+const TYPE_MAP: Record<string, string> = {
+  'text': 'string',
+  'int': 'number',
+  'integer': 'number',
+  'serial': 'number',
+  'bigint': 'number', // JS numbers are doubles, usually fine for IDs, or use string/bigint
+  'boolean': 'boolean',
+  'jsonb': 'any',
+  'timestamptz': 'string',
+  'date': 'string',
+  'decimal': 'number'
+};
+
+// Map param types from subscribable definitions
+const PARAM_TYPE_MAP: Record<string, string> = {
+  'int': 'number',
+  'integer': 'number',
+  'text': 'string',
+  'string': 'string',
+  'boolean': 'boolean',
+  'date': 'string',
+  'timestamptz': 'string'
+};
+
+export function generateTypeDefinitions(
+  entities: Record<string, EntityIR>,
+  subscribables?: Record<string, SubscribableIR>
+): string {
+  let output = "";
+
+  // --- Common Filter Types ---
+  output += `// Filter operators for search queries
+export interface FilterOperators<T> {
+  eq?: T;
+  ne?: T;
+  gt?: T;
+  gte?: T;
+  lt?: T;
+  lte?: T;
+  in?: T[];
+  not_in?: T[];
+  ilike?: string;
+  is_null?: boolean;
+}
+
+export type FilterValue<T> = T | FilterOperators<T>;
+
+`;
+
+  for (const [name, entity] of Object.entries(entities)) {
+    const pascalName = toPascalCase(name);
+
+    // 1. Generate Entity Interface (Read Model)
+    output += `export interface ${pascalName} {\n`;
+    for (const col of entity.columns) {
+      const tsType = mapPostgresToTs(col.type);
+      const nullable = !col.type.toUpperCase().includes('NOT NULL') && !col.type.toUpperCase().includes('PRIMARY KEY');
+      output += `  ${col.name}${nullable ? '?' : ''}: ${tsType};\n`;
+    }
+    output += `}\n\n`;
+
+    // 2. Generate Save Params Interface (Write Model)
+    output += `export interface Save${pascalName}Params {\n`;
+    for (const col of entity.columns) {
+      const tsType = mapPostgresToTs(col.type);
+      const isPk = entity.primaryKey.includes(col.name);
+      const hasDefault = col.type.toUpperCase().includes('DEFAULT') || col.type.includes('serial');
+      const isOptional = isPk || hasDefault || !col.type.toUpperCase().includes('NOT NULL');
+      output += `  ${col.name}${isOptional ? '?' : ''}: ${tsType};\n`;
+    }
+    output += `}\n\n`;
+
+    // 3. Generate Get/Delete Params (PK)
+    output += `export interface ${pascalName}PK {\n`;
+    for (const pkCol of entity.primaryKey) {
+        const col = entity.columns.find(c => c.name === pkCol);
+        if (col) {
+            output += `  ${col.name}: ${mapPostgresToTs(col.type)};\n`;
+        }
+    }
+    output += `}\n\n`;
+
+    // 4. Generate Search Filters Interface
+    output += `export interface ${pascalName}Filters {\n`;
+    for (const col of entity.columns) {
+      const tsType = mapPostgresToTs(col.type);
+      output += `  ${col.name}?: FilterValue<${tsType}>;\n`;
+    }
+    output += `}\n\n`;
+
+    // 5. Generate Search Params Interface
+    output += `export interface Search${pascalName}Params {
+  filters?: ${pascalName}Filters;
+  sort_field?: keyof ${pascalName};
+  sort_order?: 'asc' | 'desc';
+  limit?: number;
+  offset?: number;
+}\n\n`;
+
+    // 6. Generate Lookup Params Interface
+    output += `export interface Lookup${pascalName}Params {
+  q?: string;
+  limit?: number;
+}\n\n`;
+  }
+
+  // --- Subscribable Params ---
+  if (subscribables) {
+    for (const [name, sub] of Object.entries(subscribables)) {
+      const pascalName = toPascalCase(name);
+
+      output += `export interface ${pascalName}Params {\n`;
+      for (const [paramName, paramType] of Object.entries(sub.params)) {
+        const tsType = PARAM_TYPE_MAP[paramType as string] || 'any';
+        output += `  ${paramName}: ${tsType};\n`;
+      }
+      output += `}\n\n`;
+    }
+  }
+
+  return output;
+}
+
+function mapPostgresToTs(pgType: string): string {
+  // Handle arrays: text[] -> string[]
+  if (pgType.endsWith('[]')) {
+      const base = pgType.slice(0, -2);
+      return mapPostgresToTs(base) + '[]';
+  }
+
+  // Simple map
+  for (const [key, val] of Object.entries(TYPE_MAP)) {
+      if (pgType.toLowerCase().includes(key)) return val;
+  }
+  return 'any';
+}
+
+function toPascalCase(str: string) {
+    return str.replace(/(^|_)([a-z])/g, (g) => (g.at(-1) ?? '').toUpperCase());
+}

package/src/cli/compiler/analyzer.ts

@@ -0,0 +1,52 @@
+import type { DomainConfig, EntityConfig, SubscribableConfig, IncludeConfig } from "../../shared/ir.js";
+
+/**
+ * Analyzes a domain configuration for errors and inconsistencies
+ */
+export function analyzeDomain(domain: DomainConfig): string[] {
+  const errors: string[] = [];
+  const entities = domain.entities;
+  const subscribables = domain.subscribables || {};
+
+  // 1. Validate Subscribables
+  for (const [subName, subConfig] of Object.entries(subscribables)) {
+    const rootEntity = subConfig.root?.entity;
+
+    // Check root entity existence
+    if (!rootEntity) {
+      errors.push(`Subscribable '${subName}' missing root entity.`);
+    } else if (!entities[rootEntity]) {
+      errors.push(`Subscribable '${subName}' references unknown root entity '${rootEntity}'.`);
+    }
+
+    // Recursively check includes
+    const validateIncludes = (includes: Record<string, string | IncludeConfig> | undefined, parentEntity: string) => {
+      if (!includes) return;
+
+      for (const [relName, relConfig] of Object.entries(includes)) {
+        const targetEntity = typeof relConfig === 'string'
+            ? relConfig
+            : relConfig.entity;
+
+        if (!targetEntity) {
+           errors.push(`Relation '${relName}' in '${subName}' missing target entity.`);
+           continue;
+        }
+        if (!entities[targetEntity]) {
+          errors.push(`Relation '${relName}' in '${subName}' references unknown entity '${targetEntity}'.`);
+        }
+
+        // Recursively validate nested includes
+        if (typeof relConfig !== 'string' && relConfig.includes) {
+          validateIncludes(relConfig.includes, targetEntity);
+        }
+      }
+    };
+
+    if (subConfig.includes) {
+      validateIncludes(subConfig.includes, rootEntity);
+    }
+  }
+
+  return errors;
+}

package/src/cli/compiler/graph_rules.ts

@@ -0,0 +1,251 @@
+import type { GraphRuleIR } from "../../shared/ir.js";
+
+/**
+ * Resolves a value reference (like @id, @user_id, @before.field, @after.field)
+ * into the appropriate SQL expression based on the trigger context.
+ * @param value - The value to resolve (may be @variable or literal)
+ * @param trigger - The trigger context ('create', 'update', 'delete')
+ * @param castToInt - Whether to cast the result to integer (for FK columns)
+ */
+function resolveValue(value: string, trigger: string, castToInt: boolean = false): string {
+  if (typeof value !== 'string') {
+    return String(value);
+  }
+
+  if (!value.startsWith('@')) {
+    // Literal string value
+    return `'${value}'`;
+  }
+
+  const varName = value.substring(1);
+  const intCast = castToInt ? '::int' : '';
+
+  // Special @before.field references (for update/delete triggers)
+  if (varName.startsWith('before.')) {
+    const field = varName.substring(7);
+    return `(v_old_data->>'${field}')${intCast}`;
+  }
+
+  // Special @after.field references (for update triggers)
+  if (varName.startsWith('after.')) {
+    const field = varName.substring(6);
+    return `(v_result->>'${field}')${intCast}`;
+  }
+
+  // Handle special keywords
+  switch (varName) {
+    case 'user_id':
+      return 'p_user_id';
+    case 'today':
+      return 'CURRENT_DATE';
+    case 'now':
+      return 'NOW()';
+    default:
+      // Generic field reference - use appropriate record based on trigger
+      if (trigger === 'delete') {
+        return `(v_old_data->>'${varName}')${intCast}`;
+      } else {
+        return `(v_result->>'${varName}')${intCast}`;
+      }
+  }
+}
+
+/**
+ * Resolves a condition string, replacing @before.field, @after.field, etc.
+ * with the appropriate SQL expressions.
+ */
+function resolveCondition(condition: string, trigger: string): string {
+  let sql = condition;
+
+  // Replace @before.field references
+  sql = sql.replace(/@before\.(\w+)/g, (_match, field) => {
+    return `(v_old_data->>'${field}')`;
+  });
+
+  // Replace @after.field references
+  sql = sql.replace(/@after\.(\w+)/g, (_match, field) => {
+    if (trigger === 'update' || trigger === 'create') {
+      return `(v_result->>'${field}')`;
+    }
+    return `(v_result->>'${field}')`;
+  });
+
+  // Replace @field references (current record)
+  sql = sql.replace(/@(\w+)(?!\w)/g, (_match, field) => {
+    if (field === 'user_id') {
+      return 'p_user_id';
+    } else if (field === 'id') {
+      if (trigger === 'delete') {
+        return `(p_pk->>'id')`;
+      } else {
+        return `(v_result->>'id')`;
+      }
+    } else {
+      if (trigger === 'delete') {
+        return `(v_old_data->>'${field}')`;
+      } else {
+        return `(v_result->>'${field}')`;
+      }
+    }
+  });
+
+  return sql;
+}
+
+export function compileGraphRules(entity: string, trigger: string, rules: GraphRuleIR[]): string {
+  if (!rules || rules.length === 0) return "";
+
+  let sql = "";
+
+  // Group rules by condition for efficient IF block generation
+  // For now, handle each rule individually (can optimize later for same conditions)
+  for (const rule of rules) {
+    const comment = rule.description || rule.ruleName || rule.action;
+    let actionSql = "";
+
+    // === REACTOR ===
+    if (rule.action === 'reactor') {
+      const name = rule.target;
+      const params = rule.params || {};
+
+      // Build JSON object using jsonb_build_object
+      const jsonArgs: string[] = [];
+      for (const [key, val] of Object.entries(params)) {
+        const valueExpr = resolveValue(val, trigger);
+        jsonArgs.push(`'${key}', ${valueExpr}`);
+      }
+
+      const dataJson = jsonArgs.length > 0
+        ? `jsonb_build_object(${jsonArgs.join(', ')})`
+        : `'{}'::jsonb`;
+
+      actionSql = `
+  -- Graph Rule: Reactor ${name}
+  INSERT INTO dzql_v2.events (commit_id, table_name, op, pk, data, user_id)
+  VALUES (
+    v_commit_id,
+    '${entity}',
+    'reactor:${name}',
+    jsonb_build_object('id', ${trigger === 'delete' ? "(p_pk->>'id')::text" : "(v_result->>'id')::text"}),
+    ${dataJson},
+    p_user_id
+  );`;
+    }
+
+    // === CREATE SIDE EFFECT ===
+    if (rule.action === 'create') {
+      const target = rule.target;
+      const data = rule.params || {};
+      const cols: string[] = [];
+      const vals: string[] = [];
+
+      for (const [key, val] of Object.entries(data)) {
+        cols.push(key);
+        // Cast to int for columns that look like FK or ID columns
+        const needsIntCast = key.endsWith('_id') || key === 'id';
+        vals.push(resolveValue(val, trigger, needsIntCast));
+      }
+
+      actionSql = `
+  -- Graph Rule: Create ${target}
+  INSERT INTO ${target} (${cols.join(', ')})
+  VALUES (${vals.join(', ')});`;
+    }
+
+    // === UPDATE SIDE EFFECT ===
+    if (rule.action === 'update') {
+      const target = rule.target;
+      const data = rule.params || {};
+      const match = rule.match || {};
+
+      const setClauses: string[] = [];
+      for (const [key, val] of Object.entries(data)) {
+        const needsIntCast = key.endsWith('_id') || key === 'id';
+        setClauses.push(`${key} = ${resolveValue(val, trigger, needsIntCast)}`);
+      }
+
+      const whereClauses: string[] = [];
+      for (const [key, val] of Object.entries(match)) {
+        const needsIntCast = key.endsWith('_id') || key === 'id';
+        whereClauses.push(`${key} = ${resolveValue(val, trigger, needsIntCast)}`);
+      }
+
+      const whereClause = whereClauses.length > 0 ? whereClauses.join(' AND ') : 'TRUE';
+
+      actionSql = `
+  -- Graph Rule: Update ${target}
+  UPDATE ${target}
+  SET ${setClauses.join(', ')}
+  WHERE ${whereClause};`;
+    }
+
+    // === DELETE CASCADE ===
+    if (rule.action === 'delete') {
+      const target = rule.target;
+      const match = rule.match || rule.params || {};
+      const whereClauses: string[] = [];
+
+      for (const [key, val] of Object.entries(match)) {
+        const needsIntCast = key.endsWith('_id') || key === 'id';
+        whereClauses.push(`${key} = ${resolveValue(val, trigger, needsIntCast)}`);
+      }
+
+      const whereClause = whereClauses.length > 0 ? whereClauses.join(' AND ') : 'TRUE';
+
+      actionSql = `
+  -- Graph Rule: Delete ${target}
+  DELETE FROM ${target} WHERE ${whereClause};`;
+    }
+
+    // === VALIDATE ===
+    if (rule.action === 'validate') {
+      const functionName = rule.target;
+      const params = rule.params || {};
+      const errorMessage = rule.error_message || 'Validation failed';
+
+      const paramList: string[] = [];
+      for (const [key, val] of Object.entries(params)) {
+        paramList.push(`${key} => ${resolveValue(val, trigger)}`);
+      }
+
+      const paramSQL = paramList.length > 0 ? paramList.join(', ') : '';
+
+      actionSql = `
+  -- Graph Rule: Validate (${comment})
+  IF NOT ${functionName}(${paramSQL}) THEN
+    RAISE EXCEPTION '${errorMessage}';
+  END IF;`;
+    }
+
+    // === EXECUTE ===
+    if (rule.action === 'execute') {
+      const functionName = rule.target;
+      const params = rule.params || {};
+
+      const paramList: string[] = [];
+      for (const [key, val] of Object.entries(params)) {
+        paramList.push(`${key} => ${resolveValue(val, trigger)}`);
+      }
+
+      const paramSQL = paramList.length > 0 ? paramList.join(', ') : '';
+
+      actionSql = `
+  -- Graph Rule: Execute ${functionName}
+  PERFORM ${functionName}(${paramSQL});`;
+    }
+
+    // Wrap in condition IF block if condition is present
+    if (rule.condition && actionSql) {
+      const conditionSQL = resolveCondition(rule.condition, trigger);
+      sql += `
+  -- Condition: ${rule.condition}
+  IF ${conditionSQL} THEN${actionSql}
+  END IF;
+`;
+    } else if (actionSql) {
+      sql += actionSql + '\n';
+    }
+  }
+
+  return sql;
+}