@cedarjs/cli 3.0.0-canary.13429 → 3.0.0-canary.13430

package/dist/commands/setup/live-queries/liveQueries.js

@@ -0,0 +1,31 @@
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+const command = "live-queries";
+const description = "Setup live query invalidation with Postgres notifications";
+function builder(yargs) {
+  yargs.option("force", {
+    alias: "f",
+    default: false,
+    description: "Overwrite existing configuration",
+    type: "boolean"
+  }).option("verbose", {
+    alias: "v",
+    default: false,
+    description: "Print more logs",
+    type: "boolean"
+  });
+}
+async function handler(options) {
+  recordTelemetryAttributes({
+    command: "setup live-queries",
+    force: options.force,
+    verbose: options.verbose
+  });
+  const { handler: handler2 } = await import("./liveQueriesHandler.js");
+  return handler2(options);
+}
+export {
+  builder,
+  command,
+  description,
+  handler
+};

package/dist/commands/setup/live-queries/liveQueriesHandler.js

@@ -0,0 +1,282 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Listr } from "listr2";
+import { addApiPackages } from "@cedarjs/cli-helpers";
+import { getMigrationsPath, getSchemaPath } from "@cedarjs/project-config";
+import { errorTelemetry } from "@cedarjs/telemetry";
+import c from "../../../lib/colors.js";
+import { getPaths, transformTSToJS, writeFile } from "../../../lib/index.js";
+import { isTypeScriptProject } from "../../../lib/project.js";
+const getApiPackageJson = () => {
+  const apiPackageJsonPath = path.join(getPaths().api.base, "package.json");
+  return JSON.parse(fs.readFileSync(apiPackageJsonPath, "utf-8"));
+};
+const hasPackage = (packageJson, packageName) => {
+  return Boolean(
+    packageJson.dependencies?.[packageName] || packageJson.devDependencies?.[packageName]
+  );
+};
+const getPrismaProvider = async () => {
+  try {
+    const prismaConfigPath = getPaths().api.prismaConfig;
+    if (!prismaConfigPath) {
+      return void 0;
+    }
+    let schemaPath = await getSchemaPath(prismaConfigPath);
+    if (!schemaPath) {
+      return void 0;
+    }
+    let stat;
+    try {
+      stat = fs.statSync(schemaPath);
+    } catch (e) {
+      stat = void 0;
+    }
+    if (stat && stat.isDirectory()) {
+      const candidate = path.join(schemaPath, "schema.prisma");
+      if (fs.existsSync(candidate)) {
+        schemaPath = candidate;
+      } else {
+        return void 0;
+      }
+    }
+    if (!fs.existsSync(schemaPath)) {
+      return void 0;
+    }
+    const content = fs.readFileSync(schemaPath, "utf-8");
+    const match = content.match(/^\s*provider\s*=\s*["']([^"']+)["']/im);
+    if (match && match[1]) {
+      return match[1].toLowerCase();
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+};
+const findExistingLiveQueryMigration = ({ migrationsDirectoryPath }) => {
+  if (!fs.existsSync(migrationsDirectoryPath)) {
+    return void 0;
+  }
+  const globPattern = path.join(migrationsDirectoryPath, "*", "migration.sql").replaceAll("\\", "/");
+  const migrationFilePaths = fs.globSync(globPattern);
+  return migrationFilePaths.find((migrationFilePath) => {
+    const content = fs.readFileSync(migrationFilePath, "utf-8");
+    return content.includes("cedar_notify_table_change");
+  });
+};
+const generateMigrationFolderName = () => {
+  const now = /* @__PURE__ */ new Date();
+  const year = String(now.getFullYear());
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  const hour = String(now.getHours()).padStart(2, "0");
+  const minute = String(now.getMinutes()).padStart(2, "0");
+  const second = String(now.getSeconds()).padStart(2, "0");
+  return `${year}${month}${day}${hour}${minute}${second}_live_queries_notifications`;
+};
+const addLiveQueryListenerToGraphqlHandler = ({ force }) => {
+  const graphqlHandlerPath = path.join(
+    getPaths().api.functions,
+    `graphql.${isTypeScriptProject() ? "ts" : "js"}`
+  );
+  if (!fs.existsSync(graphqlHandlerPath)) {
+    return {
+      skipped: true,
+      reason: "GraphQL handler not found"
+    };
+  }
+  const contentLines = fs.readFileSync(graphqlHandlerPath, "utf-8").split("\n");
+  const importLineRegex = /^import {.*startLiveQueryListener.*} from ['"]src\/lib\/liveQueriesListener['"];?$/;
+  const multilineImportRegex = /^} from ['"]src\/lib\/liveQueriesListener['"];?$/;
+  const hasImport = contentLines.some((line) => {
+    return importLineRegex.test(line) || multilineImportRegex.test(line);
+  });
+  const hasStartCall = contentLines.some(
+    (line) => line.trim().startsWith("startLiveQueryListener(") || line.trim().startsWith("void startLiveQueryListener(")
+  );
+  if (hasImport && hasStartCall && !force) {
+    return {
+      skipped: true,
+      reason: "Listener is already wired into GraphQL handler"
+    };
+  }
+  const handlerIndex = contentLines.findLastIndex(
+    (line) => line === "export const handler = createGraphQLHandler({"
+  );
+  if (handlerIndex === -1) {
+    return {
+      skipped: true,
+      reason: "Unexpected syntax. Handler not found"
+    };
+  }
+  const lastImportIndex = contentLines.slice(0, handlerIndex).findLastIndex((line) => line.startsWith("import "));
+  if (lastImportIndex === -1) {
+    return {
+      skipped: true,
+      reason: "Unexpected syntax. No imports found"
+    };
+  }
+  if (!hasImport) {
+    contentLines.splice(
+      lastImportIndex + 1,
+      0,
+      "import { startLiveQueryListener } from 'src/lib/liveQueriesListener'"
+    );
+  }
+  const handlerIndexAfterImport = hasImport ? handlerIndex : handlerIndex + 1;
+  if (!hasStartCall) {
+    contentLines.splice(
+      handlerIndexAfterImport,
+      0,
+      "",
+      "void startLiveQueryListener()"
+    );
+  }
+  fs.writeFileSync(graphqlHandlerPath, contentLines.join("\n"));
+  return {
+    skipped: false
+  };
+};
+const handler = async ({ force }) => {
+  const projectIsTypescript = isTypeScriptProject();
+  const apiPackageJson = getApiPackageJson();
+  const migrationsPath = await getMigrationsPath(getPaths().api.prismaConfig);
+  const hasRealtimeDependency = hasPackage(apiPackageJson, "@cedarjs/realtime");
+  const hasPgDependency = hasPackage(apiPackageJson, "pg");
+  const ext = projectIsTypescript ? "ts" : "js";
+  const migrationTemplatePath = path.resolve(
+    import.meta.dirname,
+    "templates",
+    "migration.sql.template"
+  );
+  const listenerTemplatePath = path.resolve(
+    import.meta.dirname,
+    "templates",
+    "liveQueriesListener.ts.template"
+  );
+  const existingMigrationPath = findExistingLiveQueryMigration({
+    migrationsDirectoryPath: migrationsPath
+  });
+  const migrationDirPath = path.join(
+    migrationsPath,
+    generateMigrationFolderName()
+  );
+  const migrationPath = path.join(migrationDirPath, "migration.sql");
+  const listenerPath = path.join(
+    getPaths().api.lib,
+    `liveQueriesListener.${ext}`
+  );
+  const tasks = new Listr(
+    [
+      {
+        title: "Checking for @cedarjs/realtime in api workspace...",
+        task: () => {
+          if (!hasRealtimeDependency) {
+            throw new Error(
+              `@cedarjs/realtime is not installed in your api workspace. Please run ${c.highlight("yarn cedar setup realtime")} first.`
+            );
+          }
+        }
+      },
+      {
+        title: "Checking that your database provider is PostgreSQL...",
+        task: async () => {
+          const prismaProvider = await getPrismaProvider();
+          const unsupportedProviders = /* @__PURE__ */ new Set([
+            "sqlite",
+            "mysql",
+            "mongodb",
+            "sqlserver",
+            "cockroachdb"
+          ]);
+          if (prismaProvider && unsupportedProviders.has(prismaProvider)) {
+            throw new Error(
+              `Only PostgreSQL is supported for now (found provider "${prismaProvider}").`
+            );
+          }
+        }
+      },
+      {
+        ...addApiPackages(["pg@^8.18.0"]),
+        title: "Adding pg dependency to your api side...",
+        skip: () => {
+          if (hasPgDependency) {
+            return "pg is already installed";
+          }
+        }
+      },
+      {
+        title: "Adding live query notification migration...",
+        task: () => {
+          const migrationTemplate = fs.readFileSync(
+            migrationTemplatePath,
+            "utf-8"
+          );
+          const targetPath = force && existingMigrationPath ? existingMigrationPath : migrationPath;
+          writeFile(targetPath, migrationTemplate, {
+            overwriteExisting: force
+          });
+        },
+        skip: () => {
+          if (existingMigrationPath && !force) {
+            const migrationPath2 = path.relative(
+              getPaths().base,
+              existingMigrationPath
+            );
+            return `Existing live query migration found: ${migrationPath2}`;
+          }
+        }
+      },
+      {
+        title: `Adding api/src/lib/liveQueriesListener.${ext}...`,
+        task: async () => {
+          const listenerTemplate = fs.readFileSync(
+            listenerTemplatePath,
+            "utf-8"
+          );
+          const listenerContent = projectIsTypescript ? listenerTemplate : await transformTSToJS(listenerPath, listenerTemplate);
+          writeFile(listenerPath, listenerContent, {
+            overwriteExisting: force
+          });
+        }
+      },
+      {
+        title: "Wiring listener startup into GraphQL handler...",
+        task: (_ctx, task) => {
+          const result = addLiveQueryListenerToGraphqlHandler({ force });
+          if (result.skipped) {
+            task.skip(result.reason);
+          }
+        }
+      },
+      {
+        title: "One more thing...",
+        task: (_ctx, task) => {
+          task.title = `One more thing...
+
+          ${c.success("\nLive query notifications configured!\n")}
+
+          Apply the migration to activate Postgres notifications:
+          ${c.highlight("\n\xA0\xA0yarn cedar prisma migrate dev\n")}
+
+          Then run the API server and use @live queries with invalidation keys
+          based on your GraphQL types and fields.
+        `;
+        }
+      }
+    ],
+    {
+      rendererOptions: { collapseSubtasks: false }
+    }
+  );
+  try {
+    await tasks.run();
+  } catch (e) {
+    errorTelemetry(process.argv, e.message);
+    console.error(c.error(e.message));
+    process.exit(e?.exitCode || 1);
+  }
+};
+export {
+  handler
+};

package/dist/commands/setup/live-queries/templates/liveQueriesListener.ts.template

@@ -0,0 +1,137 @@
+import { Client } from 'pg'
+
+import { liveQueryStore } from '@cedarjs/realtime'
+
+import { logger } from 'src/lib/logger'
+
+const LIVE_QUERY_CHANNEL = 'table_change'
+const RECONNECT_DELAY_MS = 5000
+
+let client: Client | undefined
+let reconnectTimeout: ReturnType<typeof setTimeout> | undefined
+let started = false
+let connectionGeneration = 0
+
+interface GetKeysToInvalidateArgs {
+  table: string
+  recordId: string
+}
+
+function getKeysToInvalidate({ table, recordId }: GetKeysToInvalidateArgs) {
+  const keys = [
+    `Query.${table}`,
+    `Query.${table.toLocaleLowerCase()}`,
+    `${table}:${recordId}`
+  ]
+
+  return keys
+}
+
+function reconnect(generation: number) {
+  if (reconnectTimeout) {
+    return
+  }
+
+  reconnectTimeout = setTimeout(async () => {
+    reconnectTimeout = undefined
+
+    if (generation !== connectionGeneration) {
+      return
+    }
+
+    await connect()
+  }, RECONNECT_DELAY_MS)
+}
+
+interface NotificationPayload {
+  table: string
+  operation: string
+  recordId: string
+}
+
+async function onNotification(payload: string | undefined) {
+  if (!payload) {
+    return
+  }
+
+  try {
+    const parsed: NotificationPayload = JSON.parse(payload)
+    const keys = getKeysToInvalidate(parsed)
+
+    await liveQueryStore?.invalidate(keys)
+
+    logger.debug(
+      { operation: parsed.operation, table: parsed.table, keys },
+      'Invalidated live query keys from Postgres notification'
+    )
+  } catch (error) {
+    logger.error(
+      { error, payload },
+      'Failed to process Postgres notification payload'
+    )
+  }
+}
+
+async function connect() {
+  connectionGeneration = connectionGeneration + 1
+  const generation = connectionGeneration
+
+  try {
+    if (reconnectTimeout) {
+      clearTimeout(reconnectTimeout)
+      reconnectTimeout = undefined
+    }
+
+    if (client) {
+      const previousClient = client
+      client = undefined
+      previousClient.removeAllListeners()
+      await previousClient.end().catch(() => {})
+    }
+
+    const nextClient = new Client({
+      connectionString: process.env.DATABASE_URL,
+    })
+
+    nextClient.on('notification', async (msg) => {
+      await onNotification(msg.payload)
+    })
+
+    nextClient.on('error', (error) => {
+      logger.error(
+        { error },
+        'Postgres live query listener encountered an error'
+      )
+      reconnect(generation)
+    })
+
+    nextClient.on('end', () => {
+      logger.warn('Postgres live query listener disconnected')
+      reconnect(generation)
+    })
+
+    await nextClient.connect()
+    await nextClient.query(`LISTEN ${LIVE_QUERY_CHANNEL}`)
+
+    if (generation !== connectionGeneration) {
+      nextClient.removeAllListeners()
+      await nextClient.end().catch(() => {})
+      return
+    }
+
+    client = nextClient
+    logger.info('Postgres live query listener connected')
+  } catch (error) {
+    logger.error({ error }, 'Failed to connect Postgres live query listener')
+    reconnect(generation)
+  }
+}
+
+export async function startLiveQueryListener() {
+  if (started) {
+    return
+  }
+
+  started = true
+  await connect()
+}

package/dist/commands/setup/live-queries/templates/migration.sql.template

@@ -0,0 +1,98 @@
+CREATE OR REPLACE FUNCTION cedar_notify_table_change() RETURNS TRIGGER AS $$
+DECLARE
+  record_id text;
+BEGIN
+  IF (TG_OP = 'DELETE') THEN
+    record_id := OLD.id::text;
+  ELSE
+    record_id := NEW.id::text;
+  END IF;
+
+  PERFORM pg_notify(
+    'table_change',
+    json_build_object(
+      'table', TG_TABLE_NAME,
+      'operation', TG_OP,
+      'recordId', record_id
+    )::text
+  );
+
+  RETURN NULL;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE FUNCTION cedar_attach_notify_triggers() RETURNS void AS $$
+DECLARE
+  table_record record;
+BEGIN
+  FOR table_record IN
+    SELECT table_schema, table_name
+    FROM information_schema.tables
+    WHERE table_type = 'BASE TABLE'
+      AND table_schema NOT IN ('pg_catalog', 'information_schema')
+      AND table_name <> '_prisma_migrations'
+  LOOP
+    EXECUTE format(
+      'DROP TRIGGER IF EXISTS cedar_notify_change_trigger ON %I.%I',
+      table_record.table_schema,
+      table_record.table_name
+    );
+
+    EXECUTE format(
+      'CREATE TRIGGER cedar_notify_change_trigger
+       AFTER INSERT OR UPDATE OR DELETE ON %I.%I
+       FOR EACH ROW EXECUTE FUNCTION cedar_notify_table_change()',
+      table_record.table_schema,
+      table_record.table_name
+    );
+  END LOOP;
+END;
+$$ LANGUAGE plpgsql;
+
+SELECT cedar_attach_notify_triggers();
+
+CREATE OR REPLACE FUNCTION cedar_event_on_table_create() RETURNS event_trigger AS $$
+DECLARE
+  cmd record;
+  schema_name text;
+  table_name text;
+BEGIN
+  FOR cmd IN SELECT * FROM pg_event_trigger_ddl_commands() LOOP
+    IF cmd.object_type = 'table' THEN
+      schema_name := cmd.schema_name;
+      table_name := regexp_replace(cmd.object_identity, '^.*\\.', '');
+
+      IF schema_name IS NULL THEN
+        CONTINUE;
+      END IF;
+
+      IF schema_name IN ('pg_catalog', 'information_schema') THEN
+        CONTINUE;
+      END IF;
+
+      IF table_name = '_prisma_migrations' THEN
+        CONTINUE;
+      END IF;
+
+      EXECUTE format(
+        'DROP TRIGGER IF EXISTS cedar_notify_change_trigger ON %I.%I',
+        schema_name,
+        table_name
+      );
+
+      EXECUTE format(
+        'CREATE TRIGGER cedar_notify_change_trigger
+         AFTER INSERT OR UPDATE OR DELETE ON %I.%I
+         FOR EACH ROW EXECUTE FUNCTION cedar_notify_table_change()',
+        schema_name,
+        table_name
+      );
+    END IF;
+  END LOOP;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE EVENT TRIGGER cedar_on_create_table
+  ON ddl_command_end
+  WHEN TAG IN ('CREATE TABLE', 'CREATE TABLE AS')
+  EXECUTE FUNCTION cedar_event_on_table_create();

package/dist/commands/setup.js

@@ -8,6 +8,7 @@ import * as setupGenerator from "./setup/generator/generator.js";
 import * as setupGraphql from "./setup/graphql/graphql.js";
 import * as setupI18n from "./setup/i18n/i18n.js";
 import * as setupJobs from "./setup/jobs/jobs.js";
+import * as setupLiveQueries from "./setup/live-queries/liveQueries.js";
 import * as setupMailer from "./setup/mailer/mailer.js";
 import * as setupMiddleware from "./setup/middleware/middleware.js";
 import * as setupMonitoring from "./setup/monitoring/monitoring.js";
@@ -20,7 +21,7 @@ import * as setupUploads from "./setup/uploads/uploads.js";
 import * as setupVite from "./setup/vite/vite.js";
 const command = "setup <command>";
 const description = "Initialize project config and install packages";
-const builder = (yargs) => yargs.command(setupAuth).command(setupCache).command(setupDeploy).command(setupDocker).command(setupGenerator).command(setupGraphql).command(setupI18n).command(setupJobs).command(setupMailer).command(setupMiddleware).command(setupMonitoring).command(setupPackage).command(setupRealtime).command(setupServerFile).command(setupTsconfig).command(setupUi).command(setupUploads).command(setupVite).demandCommand().middleware(detectRxVersion).epilogue(
+const builder = (yargs) => yargs.command(setupAuth).command(setupCache).command(setupDeploy).command(setupDocker).command(setupGenerator).command(setupGraphql).command(setupI18n).command(setupJobs).command(setupLiveQueries).command(setupMailer).command(setupMiddleware).command(setupMonitoring).command(setupPackage).command(setupRealtime).command(setupServerFile).command(setupTsconfig).command(setupUi).command(setupUploads).command(setupVite).demandCommand().middleware(detectRxVersion).epilogue(
   `Also see the ${terminalLink(
     "CedarJS CLI Reference",
     "https://cedarjs.com/docs/cli-commands#setup"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cedarjs/cli",
-  "version": "3.0.0-canary.13429+ab1a723d3",
+  "version": "3.0.0-canary.13430+f819694cc",
   "description": "The CedarJS Command Line",
   "repository": {
     "type": "git",
@@ -34,15 +34,15 @@
     "@babel/parser": "7.29.0",
     "@babel/preset-typescript": "7.28.5",
     "@babel/runtime-corejs3": "7.29.0",
-    "@cedarjs/api-server": "3.0.0-canary.13429",
-    "@cedarjs/cli-helpers": "3.0.0-canary.13429",
-    "@cedarjs/fastify-web": "3.0.0-canary.13429",
-    "@cedarjs/internal": "3.0.0-canary.13429",
-    "@cedarjs/prerender": "3.0.0-canary.13429",
-    "@cedarjs/project-config": "3.0.0-canary.13429",
-    "@cedarjs/structure": "3.0.0-canary.13429",
-    "@cedarjs/telemetry": "3.0.0-canary.13429",
-    "@cedarjs/web-server": "3.0.0-canary.13429",
+    "@cedarjs/api-server": "3.0.0-canary.13430",
+    "@cedarjs/cli-helpers": "3.0.0-canary.13430",
+    "@cedarjs/fastify-web": "3.0.0-canary.13430",
+    "@cedarjs/internal": "3.0.0-canary.13430",
+    "@cedarjs/prerender": "3.0.0-canary.13430",
+    "@cedarjs/project-config": "3.0.0-canary.13430",
+    "@cedarjs/structure": "3.0.0-canary.13430",
+    "@cedarjs/telemetry": "3.0.0-canary.13430",
+    "@cedarjs/web-server": "3.0.0-canary.13430",
     "@listr2/prompt-adapter-enquirer": "2.0.16",
     "@opentelemetry/api": "1.9.0",
     "@opentelemetry/core": "1.30.1",
@@ -106,5 +106,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "ab1a723d3487483219e736867b1fd7fdaec7b960"
+  "gitHead": "f819694cc2036c57e405c37e92ee1fc578521573"
 }