dzql 0.5.32 → 0.6.0

package/src/cli/codegen/manifest.ts

@@ -0,0 +1,95 @@
+import { DomainIR, EntityIR, SubscribableIR } from "../../shared/ir.js";
+
+export interface Manifest {
+  version: string;
+  functions: Record<string, FunctionDef>;
+  entities: Record<string, EntityIR>;
+  subscribables: Record<string, SubscribableIR>;
+}
+
+export interface FunctionDef {
+  oid?: number; // Resolved at runtime
+  schema: string;
+  name: string;
+  args: string[];
+  returnType: string;
+  isSubscription?: boolean; // Marks subscribe_* functions for client generation
+}
+
+export function generateManifest(ir: DomainIR): Manifest {
+  const functions: Record<string, FunctionDef> = {
+    // Built-in Auth Functions
+    login_user: { schema: 'dzql_v2', name: 'login_user', args: ['p_params'], returnType: 'jsonb' },
+    register_user: { schema: 'dzql_v2', name: 'register_user', args: ['p_params'], returnType: 'jsonb' }
+  };
+
+  for (const [name, entity] of Object.entries(ir.entities)) {
+    // Skip unmanaged entities (junction tables, etc.)
+    if (entity.managed === false) {
+      continue;
+    }
+
+    // Generate standard CRUD functions
+    const operations = ['get', 'save', 'delete', 'search', 'lookup'];
+
+    for (const op of operations) {
+      const funcName = `${op}_${name}`;
+      functions[funcName] = {
+        schema: 'dzql_v2',
+        name: funcName,
+        args: op === 'get' || op === 'delete'
+            ? ['p_user_id', 'p_pk']
+            : op === 'save'
+                ? ['p_user_id', 'p_data']
+                : ['p_user_id', 'p_query'],
+        returnType: 'jsonb'
+      };
+    }
+  }
+
+  for (const [subName, subIR] of Object.entries(ir.subscribables)) {
+      console.log(`[Manifest] Adding subscribable: ${subName}`);
+
+      // get_<name> - snapshot function
+      functions[`get_${subName}`] = {
+          schema: 'dzql_v2',
+          name: `get_${subName}`,
+          args: ['p_params', 'p_user_id'],
+          returnType: 'jsonb'
+      };
+
+      // <name>_can_subscribe - access control
+      functions[`${subName}_can_subscribe`] = {
+          schema: 'dzql_v2',
+          name: `${subName}_can_subscribe`,
+          args: ['p_user_id', 'p_params'],
+          returnType: 'boolean'
+      };
+
+      // subscribe_<name> - virtual method handled by runtime
+      functions[`subscribe_${subName}`] = {
+          schema: 'dzql_v2',
+          name: `subscribe_${subName}`,
+          args: ['p_params'],
+          returnType: 'jsonb',
+          isSubscription: true // Mark as subscription for special handling
+      };
+  }
+
+  // Add custom functions to allowlist
+  for (const fn of ir.customFunctions || []) {
+    functions[fn.name] = {
+      schema: 'dzql_v2',
+      name: fn.name,
+      args: fn.args || ['p_user_id', 'p_params'],
+      returnType: 'jsonb'
+    };
+  }
+
+  return {
+    version: "2.0.0",
+    functions,
+    entities: ir.entities, // Pass through for client generator
+    subscribables: ir.subscribables
+  };
+}

package/src/cli/codegen/pinia.ts

@@ -0,0 +1,174 @@
+import { Manifest } from "./manifest.js";
+
+function toPascalCase(str: string): string {
+  return str.replace(/(^|_)([a-z])/g, (g) => g[g.length - 1].toUpperCase());
+}
+
+export function generatePiniaStore(manifest: Manifest, entityName: string): string {
+  const entity = manifest.entities[entityName];
+  if (!entity) {
+    throw new Error(`Entity '${entityName}' not found in manifest.`);
+  }
+
+  const pkField = entity.primaryKey[0] || 'id';
+  const pascalName = toPascalCase(entityName);
+
+  // Generate column types for TypeScript interface
+  const columnTypes = entity.columns.map(col => {
+    let tsType = 'unknown';
+    const pgType = col.type.toLowerCase();
+
+    if (pgType.includes('serial') || pgType.includes('int')) {
+      tsType = 'number';
+    } else if (pgType.includes('text') || pgType.includes('varchar') || pgType.includes('char')) {
+      tsType = 'string';
+    } else if (pgType.includes('bool')) {
+      tsType = 'boolean';
+    } else if (pgType.includes('timestamp') || pgType.includes('date')) {
+      tsType = 'string'; // ISO date string
+    } else if (pgType.includes('json')) {
+      tsType = 'Record<string, unknown>';
+    } else if (pgType.includes('decimal') || pgType.includes('numeric') || pgType.includes('float') || pgType.includes('real')) {
+      tsType = 'number';
+    }
+
+    // Handle arrays
+    if (col.isArray) {
+      tsType = `${tsType}[]`;
+    }
+
+    // Make optional if not primary key and not NOT NULL
+    const isRequired = pgType.includes('not null') || pgType.includes('primary key');
+    return `  ${col.name}${isRequired ? '' : '?'}: ${tsType};`;
+  }).join('\n');
+
+  // Primary key type
+  const pkCol = entity.columns.find(c => c.name === pkField);
+  const pkType = pkCol && (pkCol.type.toLowerCase().includes('serial') || pkCol.type.toLowerCase().includes('int'))
+    ? 'number'
+    : 'string';
+
+  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 '../../client.js';
+
+/** ${pascalName} entity type */
+export interface ${pascalName} {
+${columnTypes}
+}
+
+/** Event payload for table changes */
+export interface TableChangedPayload {
+  table: string;
+  operation: 'insert' | 'update' | 'delete';
+  pk: { ${pkField}: ${pkType} };
+  data: ${pascalName} | null;
+}
+
+export const use${pascalName}Store = defineStore('${entityName}-store', () => {
+  const records: Ref<${pascalName}[]> = ref([]);
+  const loading: Ref<boolean> = ref(false);
+  const error: Ref<Error | null> = ref(null);
+
+  async function get(id: ${pkType}): Promise<${pascalName} | null> {
+    loading.value = true;
+    try {
+      const result = await ws.api.get_${entityName}({ ${pkField}: id });
+      return result as ${pascalName} | null;
+    } catch (e) {
+      error.value = e as Error;
+      throw e;
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  async function save(data: Partial<${pascalName}>): Promise<${pascalName}> {
+    loading.value = true;
+    try {
+      const result = await ws.api.save_${entityName}(data);
+      return result as ${pascalName};
+    } catch (e) {
+      error.value = e as Error;
+      throw e;
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  async function remove(id: ${pkType}): Promise<${pascalName}> {
+    loading.value = true;
+    try {
+      const result = await ws.api.delete_${entityName}({ ${pkField}: id });
+      return result as ${pascalName};
+    } catch (e) {
+      error.value = e as Error;
+      throw e;
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  async function search(query: {
+    filters?: Record<string, unknown>;
+    sort_field?: string;
+    sort_order?: 'asc' | 'desc';
+    limit?: number;
+    offset?: number;
+  } = {}): Promise<${pascalName}[]> {
+    loading.value = true;
+    try {
+      const result = await ws.api.search_${entityName}(query);
+      records.value = result as ${pascalName}[];
+      return records.value;
+    } catch (e) {
+      error.value = e as Error;
+      throw e;
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  function table_changed(payload: TableChangedPayload): void {
+    if (payload.table === '${entityName}') {
+      const pkValue = payload.pk?.${pkField};
+      const existingIndex = records.value.findIndex((r: ${pascalName}) => r.${pkField} === pkValue);
+
+      switch (payload.operation) {
+        case 'insert':
+          if (payload.data && existingIndex === -1) {
+            records.value.push(payload.data);
+          }
+          break;
+        case 'update':
+          if (payload.data && existingIndex !== -1) {
+            Object.assign(records.value[existingIndex], payload.data);
+          } else if (payload.data) {
+            records.value.push(payload.data);
+          }
+          break;
+        case 'delete':
+          if (existingIndex !== -1) {
+            records.value.splice(existingIndex, 1);
+          }
+          break;
+      }
+    }
+  }
+
+  return {
+    records,
+    loading,
+    error,
+    get,
+    save,
+    remove,
+    search,
+    table_changed,
+  };
+});
+`;
+}

package/src/cli/codegen/realtime.ts

@@ -0,0 +1,58 @@
+import type { SubscribableIR } from "../../shared/ir.js";
+
+export function generateAffectedKeysFunction(name: string, subIR: SubscribableIR): string {
+  // Logic to determine keys based on table
+  // For 'post_detail' (param: post_id), if 'posts' table updates, key is 'post_detail:' + post.id
+
+  // This is a simplified generator. In reality, it needs to traverse the 'includes' graph
+  // to find the path from the updated table back to the root parameter.
+
+  // Example for post_detail:
+  // Root: posts (key: post_id)
+  //   -> includes comments (filter: post_id=@id)
+
+  // If posts updates: key = 'post_detail:' + new.id
+  // If comments updates: key = 'post_detail:' + new.post_id
+
+  // We need to generate a CASE statement for p_table
+
+  const cases: string[] = [];
+
+  // 1. Root Entity Case
+  const rootEntity = subIR.root.entity;
+  // Assumption: the param key matches the root entity's PK or is mapped
+  // Here, param is 'post_id'. Root key is 'post_id'.
+  // If root key starts with @, it's a variable. If not, it's a param name.
+  // Wait, in blog.ts: root: { entity: 'posts', key: 'post_id' }
+  // This means the subscription param 'post_id' maps to the 'posts' entity.
+  // So if 'posts' updates, we look at its ID (assuming ID is the join key? No, 'key' is the param name).
+
+  // Simpler assumption for V2.0:
+  // subscription key = "sub_name:param_value"
+
+  // If root table updates, the param value is usually the PK of the root table.
+  cases.push(
+    `
+    WHEN '${rootEntity}' THEN
+      RETURN ARRAY['${name}:' || COALESCE(p_new->>'id', p_old->>'id')];
+  `);
+
+  // TODO: Handle related tables via traversal
+
+  return (
+    `
+CREATE OR REPLACE FUNCTION dzql_v2.${name}_affected_keys(p_table text, p_op text, p_old jsonb, p_new jsonb)
+RETURNS text[]
+LANGUAGE plpgsql
+IMMUTABLE
+AS $$
+BEGIN
+  CASE p_table
+    ${cases.join('\n')}
+    ELSE
+      RETURN ARRAY[]::text[];
+  END CASE;
+END;
+$$;
+`);
+}