@cedarjs/cli 0.0.4

package/dist/commands/generate/page/templates/stories.tsx.parameters.template

@@ -0,0 +1,13 @@
+import type { Meta, StoryObj } from '@storybook/react'
+
+import ${pascalName}Page from './${pascalName}Page'
+
+const meta: Meta<typeof ${pascalName}Page> = {
+  component: ${pascalName}Page,
+}
+
+export default meta
+
+type Story = StoryObj<typeof ${pascalName}Page>
+
+export const Primary: Story = {}

package/dist/commands/generate/page/templates/stories.tsx.template

@@ -0,0 +1,13 @@
+import type { Meta, StoryObj } from '@storybook/react'
+
+import ${pascalName}Page from './${pascalName}Page'
+
+const meta: Meta<typeof ${pascalName}Page> = {
+  component: ${pascalName}Page,
+}
+
+export default meta
+
+type Story = StoryObj<typeof ${pascalName}Page>
+
+export const Primary: Story = {}

package/dist/commands/generate/page/templates/test.tsx.template

@@ -0,0 +1,14 @@
+import { render } from '@cedarjs/testing/web'
+
+import ${pascalName}Page from './${pascalName}Page'
+
+//   Improve this test with help from the Redwood Testing Doc:
+//   https://redwoodjs.com/docs/testing#testing-pages-layouts
+
+describe('${pascalName}Page', () => {
+  it('renders successfully', () => {
+    expect(() => {
+      render(<${pascalName}Page ${propValueParam}/>)
+    }).not.toThrow()
+  })
+})

package/dist/commands/generate/realtime/realtime.js

@@ -0,0 +1,41 @@
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+const command = "realtime <name>";
+const description = "Generate a subscription or live query used with RedwoodJS Realtime";
+function builder(yargs) {
+  yargs.positional("name", {
+    type: "string",
+    description: "Name of the realtime event to setup. This should be a type or model name like: Widget, Sprocket, etc.",
+    demandOption: true
+  }).option("type", {
+    alias: "t",
+    type: "string",
+    choices: ["liveQuery", "subscription"],
+    description: "Type of realtime event to setup"
+  }).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: "generate realtime",
+    type: options.type,
+    force: options.force,
+    verbose: options.verbose
+  });
+  const { handler: handler2 } = await import("./realtimeHandler.js");
+  return handler2(options);
+}
+export {
+  builder,
+  command,
+  description,
+  handler
+};

package/dist/commands/generate/realtime/realtimeHandler.js

@@ -0,0 +1,215 @@
+import path from "path";
+import camelcase from "camelcase";
+import { Listr } from "listr2";
+import pascalcase from "pascalcase";
+import pluralize, { singular } from "pluralize";
+import prompts from "prompts";
+import { generate as generateTypes } from "@cedarjs/internal/dist/generate/generate";
+import { errorTelemetry } from "@cedarjs/telemetry";
+import c from "../../../lib/colors.js";
+import {
+  generateTemplate,
+  getPaths,
+  transformTSToJS,
+  writeFile
+} from "../../../lib/index.js";
+import { isTypeScriptProject } from "../../../lib/project.js";
+import { isRealtimeSetup, isServerFileSetup } from "../../experimental/util.js";
+const templateVariables = (name) => {
+  name = singular(name.toLowerCase());
+  return {
+    name,
+    collectionName: pluralize(name),
+    pluralName: pluralize(name),
+    pluralPascalName: pascalcase(pluralize(name)),
+    camelName: camelcase(name),
+    functionName: camelcase(name),
+    liveQueryName: `recent${pascalcase(pluralize(name))}`,
+    subscriptionQueryName: `recent${pascalcase(pluralize(name))}`,
+    subscriptionName: `listenTo${pascalcase(name)}Channel`,
+    modelName: pascalcase(name),
+    typeName: pascalcase(name),
+    channelName: `${pascalcase(name)}Channel`,
+    subscriptionInputType: `Publish${pascalcase(name)}Input`,
+    subscriptionServiceResolver: `publishTo${pascalcase(name)}Channel`
+  };
+};
+async function handler({ name, type, force, verbose }) {
+  const redwoodPaths = getPaths();
+  const ts = isTypeScriptProject();
+  name = singular(name.toLowerCase());
+  let functionType = type;
+  if (!functionType) {
+    const response = await prompts({
+      type: "select",
+      name: "functionType",
+      choices: [
+        {
+          value: "liveQuery",
+          title: "Live Query",
+          description: "Create a Live Query to watch for changes in data"
+        },
+        {
+          value: "subscription",
+          title: "Subscription",
+          description: "Create a Subscription to watch for events"
+        }
+      ],
+      message: "What type of realtime event would you like to create?"
+    });
+    functionType = response.functionType;
+  }
+  const tasks = new Listr(
+    [
+      {
+        title: "Checking for realtime environment prerequisites ...",
+        task: () => {
+          isServerFileSetup() && isRealtimeSetup();
+        }
+      },
+      {
+        title: `Adding ${name} example subscription ...`,
+        enabled: () => functionType === "subscription",
+        task: async () => {
+          const exampleSdlTemplateContent = path.resolve(
+            import.meta.dirname,
+            "templates",
+            "subscriptions",
+            "blank",
+            `blank.sdl.ts.template`
+          );
+          const sdlFile = path.join(
+            redwoodPaths.api.graphql,
+            `${name}.sdl.${isTypeScriptProject() ? "ts" : "js"}`
+          );
+          const sdlContent = ts ? exampleSdlTemplateContent : await transformTSToJS(sdlFile, exampleSdlTemplateContent);
+          const exampleServiceTemplateContent = path.resolve(
+            import.meta.dirname,
+            "templates",
+            "subscriptions",
+            "blank",
+            `blank.service.ts.template`
+          );
+          const serviceFile = path.join(
+            redwoodPaths.api.services,
+            `${name}`,
+            `${name}.${isTypeScriptProject() ? "ts" : "js"}`
+          );
+          const serviceContent = ts ? exampleServiceTemplateContent : await transformTSToJS(serviceFile, exampleServiceTemplateContent);
+          const exampleSubscriptionTemplateContent = path.resolve(
+            import.meta.dirname,
+            "templates",
+            "subscriptions",
+            "blank",
+            `blank.ts.template`
+          );
+          const exampleFile = path.join(
+            redwoodPaths.api.subscriptions,
+            `${name}`,
+            `${name}.${isTypeScriptProject() ? "ts" : "js"}`
+          );
+          const setupScriptContent = ts ? exampleSubscriptionTemplateContent : await transformTSToJS(
+            exampleFile,
+            exampleSubscriptionTemplateContent
+          );
+          return [
+            writeFile(
+              sdlFile,
+              await generateTemplate(sdlContent, templateVariables(name)),
+              {
+                overwriteExisting: force
+              }
+            ),
+            writeFile(
+              serviceFile,
+              await generateTemplate(serviceContent, templateVariables(name)),
+              {
+                overwriteExisting: force
+              }
+            ),
+            writeFile(
+              exampleFile,
+              await generateTemplate(
+                setupScriptContent,
+                templateVariables(name)
+              ),
+              {
+                overwriteExisting: force
+              }
+            )
+          ];
+        }
+      },
+      {
+        title: `Adding ${name} example live query ...`,
+        enabled: () => functionType === "liveQuery",
+        task: async () => {
+          const exampleSdlTemplateContent = path.resolve(
+            import.meta.dirname,
+            "templates",
+            "liveQueries",
+            "blank",
+            `blank.sdl.ts.template`
+          );
+          const sdlFile = path.join(
+            redwoodPaths.api.graphql,
+            `${name}.sdl.${isTypeScriptProject() ? "ts" : "js"}`
+          );
+          const sdlContent = ts ? exampleSdlTemplateContent : await transformTSToJS(sdlFile, exampleSdlTemplateContent);
+          const exampleServiceTemplateContent = path.resolve(
+            import.meta.dirname,
+            "templates",
+            "liveQueries",
+            "blank",
+            "blank.service.ts.template"
+          );
+          const serviceFile = path.join(
+            redwoodPaths.api.services,
+            `${name}`,
+            `${name}.${isTypeScriptProject() ? "ts" : "js"}`
+          );
+          const serviceContent = ts ? exampleServiceTemplateContent : await transformTSToJS(serviceFile, exampleServiceTemplateContent);
+          return [
+            writeFile(
+              sdlFile,
+              await generateTemplate(sdlContent, templateVariables(name)),
+              {
+                overwriteExisting: force
+              }
+            ),
+            writeFile(
+              serviceFile,
+              await generateTemplate(serviceContent, templateVariables(name)),
+              {
+                overwriteExisting: force
+              }
+            )
+          ];
+        }
+      },
+      {
+        title: `Generating types ...`,
+        task: async () => {
+          await generateTypes();
+          console.log(
+            "Note: You may need to manually restart GraphQL in VSCode to see the new types take effect.\n\n"
+          );
+        }
+      }
+    ],
+    {
+      rendererOptions: { collapseSubtasks: false, persistentOutput: true },
+      renderer: verbose ? "verbose" : "default"
+    }
+  );
+  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/generate/realtime/templates/liveQueries/blank/blank.sdl.ts.template

@@ -0,0 +1,27 @@
+// api/src/graphql/auctions.sdl.ts
+
+export const schema = gql`
+  type Query {
+    ${liveQueryName}(id: ID!): ${typeName} @requireAuth
+  }
+
+  type ${typeName} {
+    id: ID!
+    title: String!
+    largest${typeName}Item: ${typeName}Item
+    items: [${typeName}Item!]!
+  }
+
+  type ${typeName}Item {
+    amount: Int!
+  }
+
+  type Mutation {
+    create${typeName}Item(input: ${typeName}ItemInput!): ${typeName}Item @requireAuth
+  }
+
+  input ${typeName}ItemInput {
+    ${camelName}Id: ID!
+    amount: Int!
+  }
+`

package/dist/commands/generate/realtime/templates/liveQueries/blank/blank.service.ts.template

@@ -0,0 +1,73 @@
+// api/src/services/${name}s/${name}s.ts
+import type { LiveQueryStorageMechanism } from '@cedarjs/realtime'
+
+import { logger } from 'src/lib/logger'
+
+const ${collectionName} = [
+  { id: '1', title: 'First ${modelName}', items: [{ amount: 11 }] },
+  { id: '2', title: '2nd ${modelName}', items: [{ amount: 22 }] },
+  { id: '3', title: 'Third ${modelName}',  items: [{ amount: 33 }] },
+  { id: '4', title: '4th ${modelName}', items: [{ amount: 44 }] },
+  { id: '5', title: 'Fifth ${modelName}', items: [{ amount: 55 }] },
+]
+
+/**
+ * To test this live query, run the following in the GraphQL Playground:
+ *
+ * query GetRecent${pluralPascalName} @live {
+ *  ${liveQueryName}(id: "1") {
+ *    items {
+ *      amount
+ *    }
+ *    largest${typeName}Item {
+ *      amount
+ *    }
+ *    id
+ *    title
+ *   }
+ * }
+ *
+ * And then make a related item with the following mutation:
+ *
+ * mutation Create${typeName}Item {
+ *   create${typeName}Item(input: {${camelName}Id: "1", amount: 100}) {
+ *     amount
+ *   }
+ * }
+ */
+export const ${liveQueryName} = async ({ id }) => {
+  const found${modelName} = ${collectionName}.find((a) => a.id === id)
+  logger.debug({ id, ${name}: found${modelName} }, `${name} details`)
+  return found${modelName}
+}
+
+export const create${typeName}Item = async (
+  { input },
+  { context }: { context: { liveQueryStore: LiveQueryStorageMechanism } }
+) => {
+  const { ${camelName}Id, amount } = input
+
+  const index = ${collectionName}.findIndex((a) => a.id === ${camelName}Id)
+
+  const item = { amount }
+
+  ${collectionName}[index].items.push(item)
+  logger.debug({ ${camelName}Id, item }, 'Added item to ${collectionName}')
+
+  const key = `${typeName}:<%= '$' %>{${camelName}Id}`
+  context.liveQueryStore.invalidate(key)
+
+  logger.debug({ key }, 'Invalidated ${typeName} key in liveQueryStore')
+
+  return item
+}
+
+export const ${modelName} = {
+  largest${typeName}Item: (obj, { root }) => {
+    const [largest] = root.items.sort((a, b) => b.amount - a.amount)
+
+    logger.debug({ obj, root }, 'largest ${typeName}Item')
+
+    return largest
+  },
+}

package/dist/commands/generate/realtime/templates/realtime.ts.template

@@ -0,0 +1,42 @@
+import { RedwoodRealtimeOptions } from '@cedarjs/realtime'
+
+import subscriptions from 'src/subscriptions/**/*.{js,ts}'
+
+// if using a Redis store
+// import { Redis } from 'ioredis'
+// const publishClient = new Redis()
+// const subscribeClient = new Redis()
+
+/**
+ * Configure RedwoodJS Realtime
+ *
+ * See https://redwoodjs.com/docs/realtime
+ *
+ * Realtime supports Live Queries and Subscriptions over GraphQL SSE.
+ *
+ * Live Queries are GraphQL queries that are automatically re-run when the data they depend on changes.
+ *
+ * Subscriptions are GraphQL queries that are run when a client subscribes to a channel.
+ *
+ * Redwood Realtime
+ *  - uses a publish/subscribe model to broadcast data to clients.
+ *  - uses a store to persist Live Query and Subscription data.
+ *
+ * Redwood Realtime supports in-memory and Redis stores:
+ * - In-memory stores are useful for development and testing.
+ * - Redis stores are useful for production.
+ *
+ */
+export const realtime: RedwoodRealtimeOptions = {
+  subscriptions: {
+    subscriptions,
+    store: 'in-memory',
+    // if using a Redis store
+    // store: { redis: { publishClient, subscribeClient } },
+  },
+  liveQueries: {
+    store: 'in-memory',
+    // if using a Redis store
+    // store: { redis: { publishClient, subscribeClient } },
+  },
+}

package/dist/commands/generate/realtime/templates/subscriptions/blank/blank.sdl.ts.template

@@ -0,0 +1,20 @@
+export const schema = gql`
+  type ${typeName} {
+    from: String
+    body: String
+  }
+
+  type Query {
+    ${subscriptionQueryName}(id: ID!): [${typeName}!]! @skipAuth
+  }
+
+  input ${subscriptionInputType} {
+    id: ID!
+    from: String!
+    body: String!
+  }
+
+  type Mutation {
+    ${subscriptionServiceResolver}(input: ${subscriptionInputType}!): ${typeName}! @skipAuth
+  }
+`

package/dist/commands/generate/realtime/templates/subscriptions/blank/blank.service.ts.template

@@ -0,0 +1,19 @@
+import type { ${subscriptionInputType} } from 'types/graphql'
+
+import { logger } from 'src/lib/logger'
+import type { Publish${typeName}ChannelType } from 'src/subscriptions/${name}/${name}'
+
+export const ${subscriptionQueryName} = ({ id }) => [id]
+
+export const ${subscriptionServiceResolver} = async (
+  { input }: { input: ${subscriptionInputType} },
+  { context }: { context: { pubSub: Publish${typeName}ChannelType } }
+) => {
+  logger.debug({ input }, 'publishing ${name} ....')
+
+  const { id, from, body } = input
+
+context.pubSub.publish('${typeName}', id, { from, body })
+
+  return input
+}

package/dist/commands/generate/realtime/templates/subscriptions/blank/blank.ts.template

@@ -0,0 +1,58 @@
+import gql from 'graphql-tag'
+
+import type { PubSub } from '@cedarjs/realtime'
+
+import { logger } from 'src/lib/logger'
+
+export const schema = gql`
+  type Subscription {
+    ${subscriptionName}(id: ID!): ${typeName}! @requireAuth
+  }
+`
+
+export type Publish${typeName}Channel = {
+  ${typeName}: [id: string, payload: { from: string; body: string }]
+}
+
+export type Publish${typeName}ChannelType = PubSub<Publish${typeName}Channel>
+
+/**
+ * To test this ${typeName} subscription, run the following in one GraphQL Playground to subscribe:
+ *
+ * subscription ListenTo${channelName} {
+ *   ${subscriptionName}(id: "1") {
+ *     body
+ *     from
+ *   }
+ * }
+ *
+ *
+ * And run the following in another GraphQL Playground to publish and send a new ${name} to the channel:
+ *
+ * mutation PublishTo${channelName} {
+ *   ${subscriptionServiceResolver}(input: {id: "1", from: "hello", body: "bob"}) {
+ *     body
+ *     from
+ *   }
+ * }
+ */
+const ${subscriptionName}Subscription = {
+  ${subscriptionName}: {
+    subscribe: (
+      _,
+      { id },
+      { pubSub }: { pubSub: Publish${typeName}ChannelType }
+    ) => {
+      logger.debug({ id }, '${name} subscription')
+
+      return pubSub.subscribe('${typeName}', id)
+    },
+    resolve: (payload) => {
+      logger.debug({ payload }, '${name} subscription resolve')
+
+      return payload
+    },
+  },
+}
+
+export default ${subscriptionName}Subscription

package/dist/commands/generate/scaffold/scaffold.js

@@ -0,0 +1,38 @@
+import terminalLink from "terminal-link";
+import { createHandler, getYargsDefaults } from "../yargsCommandHelpers.js";
+const command = "scaffold <model>";
+const description = "Generate Pages, SDL, and Services files based on a given DB schema Model. Also accepts <path/model>";
+const builder = (yargs) => {
+  yargs.positional("model", {
+    description: "Model to scaffold. You can also use <path/model> to nest files by type at the given path directory (or directories). For example, 'rw g scaffold admin/post'"
+  }).option("docs", {
+    description: "Generate SDL and GraphQL comments to use in documentation",
+    type: "boolean",
+    default: false
+  }).option("tests", {
+    description: "Generate test files",
+    type: "boolean"
+  }).option("tailwind", {
+    description: "Generate TailwindCSS version of scaffold.css (automatically set to `true` if TailwindCSS config exists)",
+    type: "boolean"
+  }).option("rollback", {
+    description: "Revert all generator actions if an error occurs",
+    type: "boolean",
+    default: true
+  }).epilogue(
+    `Also see the ${terminalLink(
+      "Redwood CLI Reference",
+      "https://redwoodjs.com/docs/cli-commands#generate-scaffold"
+    )}`
+  );
+  Object.entries(getYargsDefaults()).forEach(([option, config]) => {
+    yargs.option(option, config);
+  });
+};
+const handler = createHandler("scaffold");
+export {
+  builder,
+  command,
+  description,
+  handler
+};