@cedarjs/cli 9.0.0-canary.1784 → 9.0.0-canary.3124

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

@@ -0,0 +1,448 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Listr } from "listr2";
+import { colors as c } from "@cedarjs/cli-helpers/colors";
+import {
+  addApiPackages,
+  addWebPackages
+} from "@cedarjs/cli-helpers/installHelpers";
+import { formatCedarCommand } from "@cedarjs/cli-helpers/packageManager/display";
+import {
+  getConfigPath,
+  getMigrationsPath,
+  getSchemaPath
+} from "@cedarjs/project-config";
+import { errorTelemetry } from "@cedarjs/telemetry";
+import { getPaths, transformTSToJS, writeFile } from "../../../lib/index.js";
+import { isTypeScriptProject } from "../../../lib/project.js";
+function getApiPackageJson() {
+  const apiPackageJsonPath = path.join(getPaths().api.base, "package.json");
+  return JSON.parse(fs.readFileSync(apiPackageJsonPath, "utf-8"));
+}
+function getWebPackageJson() {
+  const webPackageJsonPath = path.join(getPaths().web.base, "package.json");
+  return JSON.parse(fs.readFileSync(webPackageJsonPath, "utf-8"));
+}
+function hasPackage(packageJson, packageName) {
+  return Boolean(
+    packageJson.dependencies?.[packageName] || packageJson.devDependencies?.[packageName]
+  );
+}
+async function getPrismaProvider() {
+  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 {
+      stat = void 0;
+    }
+    if (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?.[1]) {
+      return match[1].toLowerCase();
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function 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");
+  });
+}
+function 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`;
+}
+function 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) {
+    const loggerImportIndex = contentLines.findIndex(
+      (line) => /import { logger } from ['"]src\/lib\/logger['"]/.test(line)
+    );
+    const insertIndex = loggerImportIndex >= 0 ? loggerImportIndex : lastImportIndex + 1;
+    contentLines.splice(
+      insertIndex,
+      0,
+      "import { startLiveQueryListener } from 'src/lib/liveQueriesListener'"
+    );
+  }
+  const handlerIndexAfterImport = hasImport ? handlerIndex : handlerIndex + 1;
+  if (!hasStartCall) {
+    contentLines.splice(
+      handlerIndexAfterImport,
+      0,
+      "// Fire-and-forget: we intentionally don't await this so it doesn't block the",
+      "// GraphQL handler from being registered. The listener doesn't need to be ready",
+      "// before the first request is handled.",
+      "void startLiveQueryListener()",
+      ""
+    );
+  }
+  fs.writeFileSync(graphqlHandlerPath, contentLines.join("\n"));
+  return {
+    skipped: false
+  };
+}
+function addConfigureGqlormToApp({ force }) {
+  const appPath = getPaths().web.app;
+  if (!fs.existsSync(appPath)) {
+    return {
+      skipped: true,
+      reason: `${path.basename(appPath)} not found`
+    };
+  }
+  const content = fs.readFileSync(appPath, "utf-8");
+  const contentLines = content.split("\n");
+  const hasGqlormImport = contentLines.some(
+    (line) => line.includes("from '@cedarjs/gqlorm/setup'")
+  );
+  const hasSchemaImport = contentLines.some(
+    (line) => line.includes("from '../../.cedar/gqlorm-schema.json'")
+  );
+  const hasConfigureCall = contentLines.some(
+    (line) => line.includes("configureGqlorm({ schema })")
+  );
+  if (hasGqlormImport && hasSchemaImport && hasConfigureCall && !force) {
+    return {
+      skipped: true,
+      reason: "configureGqlorm is already wired into App"
+    };
+  }
+  if (!hasGqlormImport) {
+    const redwoodWebImportIndex = contentLines.findIndex(
+      (line) => line.includes("from '@cedarjs/web'")
+    );
+    if (redwoodWebImportIndex === -1) {
+      return {
+        skipped: true,
+        reason: "Unexpected syntax. Could not find @cedarjs/web import to insert gqlorm import"
+      };
+    }
+    contentLines.splice(
+      redwoodWebImportIndex,
+      0,
+      "import { configureGqlorm } from '@cedarjs/gqlorm/setup'"
+    );
+  }
+  if (!hasSchemaImport) {
+    const fatalErrorPageIndex = contentLines.findIndex(
+      (line) => line.includes("import FatalErrorPage from 'src/pages/FatalErrorPage'")
+    );
+    if (fatalErrorPageIndex === -1) {
+      return {
+        skipped: true,
+        reason: "Unexpected syntax. Could not find FatalErrorPage import to insert schema import"
+      };
+    }
+    contentLines.splice(
+      fatalErrorPageIndex + 1,
+      0,
+      "import schema from '../../.cedar/gqlorm-schema.json' with { type: 'json' }"
+    );
+  }
+  if (!hasConfigureCall) {
+    const appComponentIndex = contentLines.findIndex(
+      (line) => /^const App\s*=/.test(line)
+    );
+    if (appComponentIndex === -1) {
+      return {
+        skipped: true,
+        reason: "Unexpected syntax. Could not find `const App =` to insert configureGqlorm call"
+      };
+    }
+    contentLines.splice(appComponentIndex, 0, "configureGqlorm({ schema })", "");
+  }
+  fs.writeFileSync(appPath, contentLines.join("\n"));
+  return {
+    skipped: false
+  };
+}
+async function handler({ force, verbose }) {
+  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 webPackageJson = getWebPackageJson();
+  const hasGqlormDependency = hasPackage(webPackageJson, "@cedarjs/gqlorm");
+  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(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(formatCedarCommand(["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}").`
+            );
+          }
+        }
+      },
+      {
+        title: "Adding [experimental.gqlorm] config...",
+        task: (_ctx, task) => {
+          const configTomlPath = getConfigPath();
+          const configFileName = path.basename(configTomlPath);
+          const configContent = fs.readFileSync(configTomlPath, "utf-8");
+          if (!configContent.includes("[experimental.gqlorm]")) {
+            writeFile(
+              configTomlPath,
+              configContent.concat(
+                "\n[experimental.gqlorm]\n  enabled = true\n"
+              ),
+              {
+                overwriteExisting: true
+              }
+            );
+          } else {
+            if (force) {
+              task.output = `Overwriting config in ${configFileName}`;
+              writeFile(
+                configTomlPath,
+                configContent.replace(
+                  "\n[experimental.gqlorm]\n  enabled = false\n",
+                  "\n[experimental.gqlorm]\n  enabled = true\n"
+                ),
+                {
+                  overwriteExisting: true
+                }
+              );
+            } else {
+              task.skip(
+                `The [experimental.gqlorm] config block already exists in ${configFileName}.`
+              );
+            }
+          }
+        },
+        rendererOptions: { persistentOutput: true }
+      },
+      {
+        ...addApiPackages(["pg@^8.18.0"]),
+        title: "Adding pg dependency to your api workspace...",
+        skip: () => {
+          if (hasPgDependency) {
+            return "pg is already installed";
+          }
+          return false;
+        }
+      },
+      {
+        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}`;
+          }
+          return false;
+        }
+      },
+      {
+        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);
+          }
+        }
+      },
+      {
+        ...addWebPackages(["@cedarjs/gqlorm"]),
+        title: "Adding @cedarjs/gqlorm to your web workspace...",
+        skip: () => {
+          if (hasGqlormDependency) {
+            return "@cedarjs/gqlorm is already installed";
+          }
+          return false;
+        }
+      },
+      {
+        title: "Wiring configureGqlorm into App.tsx...",
+        task: (_ctx, task) => {
+          const result = addConfigureGqlormToApp({ 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(`
+\xA0\xA0${formatCedarCommand(["prisma", "migrate", "dev"])}
+`)}
+
+          You're then ready to use @live queries to get real-time updates as
+          soon as something in your database changes.
+        `;
+        }
+      }
+    ],
+    {
+      rendererOptions: { collapseSubtasks: false },
+      renderer: verbose ? "verbose" : "default"
+    }
+  );
+  try {
+    await tasks.run();
+  } catch (e) {
+    if (isObject(e) && "message" in e) {
+      errorTelemetry(process.argv, e.message);
+      console.error(c.error(e.message));
+    } else {
+      errorTelemetry(process.argv, e);
+      console.error(c.error(e));
+    }
+    process.exit(isObjectWithExitCode(e) ? e.exitCode : 1);
+  }
+}
+function isObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isObjectWithExitCode(value) {
+  return isObject(value) && typeof value.exitCode === "number";
+}
+export {
+  handler
+};

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

@@ -0,0 +1,153 @@
+import { Client } from 'pg'
+
+import { getPaths, loadPrismaConfig } from '@cedarjs/project-config'
+import { liveQueryStore } from '@cedarjs/realtime'
+import { pluralize } from '@cedarjs/utils/cedarPluralize'
+
+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) {
+  // Using `toLowerCase()` rather than `toLocaleLowerCase()` because we want
+  // consistent casing across all locales.
+  const typeName = table.charAt(0).toLowerCase() + table.slice(1)
+
+  const keys = [
+    `Query.${typeName}`,
+    `Query.${pluralize(typeName)}`,
+    `${typeName}:${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
+  const prismaConfigPath = getPaths().api.prismaConfig
+  const prismaConfig = await loadPrismaConfig(prismaConfigPath)
+  const prismaDatasourceUrl = prismaConfig.datasource?.url
+
+  if (!prismaDatasourceUrl) {
+    const config = JSON.stringify(prismaConfig, null, 2)
+
+    throw new Error(
+      'Could not determine Postgres connection URL from Prisma config ' +
+        `datasource. Using parsed Prisma config: ${config}`
+    )
+  }
+
+  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: prismaDatasourceUrl })
+
+    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/experimental/live-queries/templates/migration.sql.template

@@ -0,0 +1,100 @@
+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;
+  ident_parts text[];
+BEGIN
+  FOR cmd IN SELECT * FROM pg_event_trigger_ddl_commands() LOOP
+    IF cmd.object_type = 'table' THEN
+      schema_name := cmd.schema_name;
+      ident_parts := parse_ident(cmd.object_identity);
+      table_name := ident_parts[array_length(ident_parts, 1)];
+
+      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/experimental/setupInngest.js

@@ -1,8 +1,8 @@
-import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
 import { getEpilogue } from "./util.js";
 const command = "setup-inngest";
 const description = "Setup Inngest for background, scheduled, delayed, multi-step, and fan-out jobs";
-const EXPERIMENTAL_TOPIC_ID = 4866;
+const EXPERIMENTAL_TOPIC_ID = "4866";
 const builder = (yargs) => {
   yargs.option("force", {
     alias: "f",