@cedarjs/cli 0.0.4

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

@@ -0,0 +1,309 @@
+import path from "path";
+import fs from "fs-extra";
+import { Listr } from "listr2";
+import { addApiPackages } from "@cedarjs/cli-helpers";
+import { generate as generateTypes } from "@cedarjs/internal/dist/generate/generate";
+import { errorTelemetry } from "@cedarjs/telemetry";
+import c from "../../../lib/colors.js";
+import { getPaths, transformTSToJS, writeFile } from "../../../lib/index.js";
+import { isTypeScriptProject, serverFileExists } from "../../../lib/project.js";
+import { setupServerFileTasks } from "../server-file/serverFileHandler.js";
+const { version } = JSON.parse(
+  fs.readFileSync(
+    path.resolve(import.meta.dirname, "../../../../package.json"),
+    "utf-8"
+  )
+);
+async function handler({ force, includeExamples, verbose }) {
+  const redwoodPaths = getPaths();
+  const ts = isTypeScriptProject();
+  const realtimeLibFilePath = path.join(
+    redwoodPaths.api.lib,
+    `realtime.${isTypeScriptProject() ? "ts" : "js"}`
+  );
+  const tasks = new Listr(
+    [
+      addApiPackages(["ioredis@^5", `@cedarjs/realtime@${version}`]),
+      {
+        title: "Adding the realtime api lib ...",
+        task: async () => {
+          const serverFileTemplateContent = fs.readFileSync(
+            path.resolve(
+              import.meta.dirname,
+              "templates",
+              "realtime.ts.template"
+            ),
+            "utf-8"
+          );
+          const setupScriptContent = ts ? serverFileTemplateContent : await transformTSToJS(
+            realtimeLibFilePath,
+            serverFileTemplateContent
+          );
+          return [
+            writeFile(realtimeLibFilePath, setupScriptContent, {
+              overwriteExisting: force
+            })
+          ];
+        }
+      },
+      {
+        title: "Adding Countdown example subscription ...",
+        enabled: () => includeExamples,
+        task: async () => {
+          const exampleSubscriptionTemplateContent = fs.readFileSync(
+            path.resolve(
+              import.meta.dirname,
+              "templates",
+              "subscriptions",
+              "countdown",
+              `countdown.ts.template`
+            ),
+            "utf-8"
+          );
+          const exampleFile = path.join(
+            redwoodPaths.api.subscriptions,
+            "countdown",
+            `countdown.${isTypeScriptProject() ? "ts" : "js"}`
+          );
+          const setupScriptContent = ts ? exampleSubscriptionTemplateContent : await transformTSToJS(
+            exampleFile,
+            exampleSubscriptionTemplateContent
+          );
+          return [
+            writeFile(exampleFile, setupScriptContent, {
+              overwriteExisting: force
+            })
+          ];
+        }
+      },
+      {
+        title: "Adding NewMessage example subscription ...",
+        enabled: () => includeExamples,
+        task: async () => {
+          const exampleSdlTemplateContent = fs.readFileSync(
+            path.resolve(
+              import.meta.dirname,
+              "templates",
+              "subscriptions",
+              "newMessage",
+              `rooms.sdl.ts.template`
+            ),
+            "utf-8"
+          );
+          const sdlFile = path.join(
+            redwoodPaths.api.graphql,
+            `rooms.sdl.${isTypeScriptProject() ? "ts" : "js"}`
+          );
+          const sdlContent = ts ? exampleSdlTemplateContent : await transformTSToJS(sdlFile, exampleSdlTemplateContent);
+          const exampleServiceTemplateContent = fs.readFileSync(
+            path.resolve(
+              import.meta.dirname,
+              "templates",
+              "subscriptions",
+              "newMessage",
+              `rooms.ts.template`
+            ),
+            "utf-8"
+          );
+          const serviceFile = path.join(
+            redwoodPaths.api.services,
+            "rooms",
+            `rooms.${isTypeScriptProject() ? "ts" : "js"}`
+          );
+          const serviceContent = ts ? exampleServiceTemplateContent : await transformTSToJS(serviceFile, exampleServiceTemplateContent);
+          const exampleSubscriptionTemplateContent = fs.readFileSync(
+            path.resolve(
+              import.meta.dirname,
+              "templates",
+              "subscriptions",
+              "newMessage",
+              `newMessage.ts.template`
+            ),
+            "utf-8"
+          );
+          const exampleFile = path.join(
+            redwoodPaths.api.subscriptions,
+            "newMessage",
+            `newMessage.${isTypeScriptProject() ? "ts" : "js"}`
+          );
+          const setupScriptContent = ts ? exampleSubscriptionTemplateContent : await transformTSToJS(
+            exampleFile,
+            exampleSubscriptionTemplateContent
+          );
+          return [
+            writeFile(sdlFile, sdlContent, {
+              overwriteExisting: force
+            }),
+            writeFile(serviceFile, serviceContent, {
+              overwriteExisting: force
+            }),
+            writeFile(exampleFile, setupScriptContent, {
+              overwriteExisting: force
+            })
+          ];
+        }
+      },
+      {
+        title: "Adding Auctions example live query ...",
+        enabled: () => includeExamples,
+        task: async () => {
+          const exampleSdlTemplateContent = fs.readFileSync(
+            path.resolve(
+              import.meta.dirname,
+              "templates",
+              "liveQueries",
+              "auctions",
+              `auctions.sdl.ts.template`
+            ),
+            "utf-8"
+          );
+          const sdlFile = path.join(
+            redwoodPaths.api.graphql,
+            `auctions.sdl.${isTypeScriptProject() ? "ts" : "js"}`
+          );
+          const sdlContent = ts ? exampleSdlTemplateContent : await transformTSToJS(sdlFile, exampleSdlTemplateContent);
+          const exampleServiceTemplateContent = fs.readFileSync(
+            path.resolve(
+              import.meta.dirname,
+              "templates",
+              "liveQueries",
+              "auctions",
+              `auctions.ts.template`
+            ),
+            "utf-8"
+          );
+          const serviceFile = path.join(
+            redwoodPaths.api.services,
+            "auctions",
+            `auctions.${isTypeScriptProject() ? "ts" : "js"}`
+          );
+          const serviceContent = ts ? exampleServiceTemplateContent : await transformTSToJS(serviceFile, exampleServiceTemplateContent);
+          return [
+            writeFile(sdlFile, sdlContent, {
+              overwriteExisting: force
+            }),
+            writeFile(serviceFile, serviceContent, {
+              overwriteExisting: force
+            })
+          ];
+        }
+      },
+      {
+        title: "Adding Defer example queries ...",
+        enabled: () => includeExamples,
+        task: async () => {
+          const exampleSdlTemplateContent = fs.readFileSync(
+            path.resolve(
+              import.meta.dirname,
+              "templates",
+              "defer",
+              "fastAndSlowFields",
+              `fastAndSlowFields.sdl.template`
+            ),
+            "utf-8"
+          );
+          const sdlFile = path.join(
+            redwoodPaths.api.graphql,
+            `fastAndSlowFields.sdl.${isTypeScriptProject() ? "ts" : "js"}`
+          );
+          const sdlContent = ts ? exampleSdlTemplateContent : await transformTSToJS(sdlFile, exampleSdlTemplateContent);
+          const exampleServiceTemplateContent = fs.readFileSync(
+            path.resolve(
+              import.meta.dirname,
+              "templates",
+              "defer",
+              "fastAndSlowFields",
+              `fastAndSlowFields.ts.template`
+            ),
+            "utf-8"
+          );
+          const serviceFile = path.join(
+            redwoodPaths.api.services,
+            "fastAndSlowFields",
+            `fastAndSlowFields.${isTypeScriptProject() ? "ts" : "js"}`
+          );
+          const serviceContent = ts ? exampleServiceTemplateContent : await transformTSToJS(serviceFile, exampleServiceTemplateContent);
+          return [
+            writeFile(sdlFile, sdlContent, {
+              overwriteExisting: force
+            }),
+            writeFile(serviceFile, serviceContent, {
+              overwriteExisting: force
+            })
+          ];
+        }
+      },
+      {
+        title: "Adding Stream example queries ...",
+        enabled: () => includeExamples,
+        task: async () => {
+          const exampleSdlTemplateContent = fs.readFileSync(
+            path.resolve(
+              import.meta.dirname,
+              "templates",
+              "stream",
+              "alphabet",
+              `alphabet.sdl.template`
+            ),
+            "utf-8"
+          );
+          const sdlFile = path.join(
+            redwoodPaths.api.graphql,
+            `alphabet.sdl.${isTypeScriptProject() ? "ts" : "js"}`
+          );
+          const sdlContent = ts ? exampleSdlTemplateContent : await transformTSToJS(sdlFile, exampleSdlTemplateContent);
+          const exampleServiceTemplateContent = fs.readFileSync(
+            path.resolve(
+              import.meta.dirname,
+              "templates",
+              "stream",
+              "alphabet",
+              `alphabet.ts.template`
+            ),
+            "utf-8"
+          );
+          const serviceFile = path.join(
+            redwoodPaths.api.services,
+            "alphabet",
+            `alphabet.${isTypeScriptProject() ? "ts" : "js"}`
+          );
+          const serviceContent = ts ? exampleServiceTemplateContent : await transformTSToJS(serviceFile, exampleServiceTemplateContent);
+          return [
+            writeFile(sdlFile, sdlContent, {
+              overwriteExisting: force
+            }),
+            writeFile(serviceFile, serviceContent, {
+              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 {
+    if (!serverFileExists()) {
+      tasks.add(setupServerFileTasks({ force }));
+    }
+    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/realtime/templates/defer/fastAndSlowFields/fastAndSlowFields.sdl.template

@@ -0,0 +1,14 @@
+export const schema = gql`
+  type Query {
+    """
+    A field that resolves fast.
+    """
+    fastField: String! @skipAuth
+
+    """
+    A field that resolves slowly.
+    Maybe you want to @defer this field ;)
+    """
+    slowField(waitFor: Int! = 5000): String @skipAuth
+  }
+`

package/dist/commands/setup/realtime/templates/defer/fastAndSlowFields/fastAndSlowFields.ts.template

@@ -0,0 +1,14 @@
+import { logger } from 'src/lib/logger'
+
+const wait = (time: number) =>
+  new Promise((resolve) => setTimeout(resolve, time))
+
+export const fastField = async () => {
+  return 'I am fast'
+}
+
+export const slowField = async (_, { waitFor = 5000 }) => {
+  logger.debug('waiting on slowField')
+  await wait(waitFor)
+  return 'I am slow'
+}

package/dist/commands/setup/realtime/templates/liveQueries/auctions/auctions.sdl.ts.template

@@ -0,0 +1,27 @@
+// api/src/graphql/auctions.sdl.ts
+
+export const schema = gql`
+  type Query {
+    auction(id: ID!): Auction @requireAuth
+  }
+
+  type Auction {
+    id: ID!
+    title: String!
+    highestBid: Bid
+    bids: [Bid!]!
+  }
+
+  type Bid {
+    amount: Int!
+  }
+
+  type Mutation {
+    bid(input: BidInput!): Bid @requireAuth
+  }
+
+  input BidInput {
+    auctionId: ID!
+    amount: Int!
+  }
+`

package/dist/commands/setup/realtime/templates/liveQueries/auctions/auctions.ts.template

@@ -0,0 +1,73 @@
+// api/src/services/auctions/auctions.ts
+import type { LiveQueryStorageMechanism } from '@cedarjs/realtime'
+
+import { logger } from 'src/lib/logger'
+
+const auctions = [
+  { id: '1', title: 'RedwoodJS Logo Shirt', bids: [{ amount: 20 }] },
+  { id: '2', title: 'RedwoodJS Lapel Pin', bids: [{ amount: 5 }] },
+  { id: '3', title: 'RedwoodJS Beanie', bids: [{ amount: 15 }] },
+  { id: '4', title: 'RedwoodJS Dad Hat', bids: [{ amount: 20 }] },
+  { id: '5', title: 'RedwoodJS Skater Hat', bids: [{ amount: 20 }] },
+]
+
+/**
+ * To test this live query, run the following in the GraphQL Playground:
+ *
+ * query GetCurrentAuctionBids @live {
+ *  auction(id: "1") {
+ *    bids {
+ *      amount
+ *    }
+ *    highestBid {
+ *      amount
+ *    }
+ *    id
+ *    title
+ *   }
+ * }
+ *
+ * And then make a bid with the following mutation:
+ *
+ * mutation MakeBid {
+ *   bid(input: {auctionId: "1", amount: 10}) {
+ *     amount
+ *   }
+ * }
+ */
+export const auction = async ({ id }) => {
+  const foundAuction = auctions.find((a) => a.id === id)
+  logger.debug({ id, auction: foundAuction }, 'auction')
+  return foundAuction
+}
+
+export const bid = async (
+  { input },
+  { context }: { context: { liveQueryStore: LiveQueryStorageMechanism } }
+) => {
+  const { auctionId, amount } = input
+
+  const index = auctions.findIndex((a) => a.id === auctionId)
+
+  const bid = { amount }
+
+  auctions[index].bids.push(bid)
+  logger.debug({ auctionId, bid }, 'Added bid to auction')
+
+  const key = `Auction:${auctionId}`
+  context.liveQueryStore.invalidate(key)
+
+  logger.debug({ key }, 'Invalidated auction key in liveQueryStore')
+
+  return bid
+}
+
+export const Auction = {
+  highestBid: (obj, { root }) => {
+    const [max] = root.bids.sort((a, b) => b.amount - a.amount)
+
+    logger.debug({ obj, root }, 'highestBid')
+
+    return max
+  },
+}

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

@@ -0,0 +1,46 @@
+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.
+ *  - and enable defer and stream directives to improve latency
+ *    for clients by sending data the most important data as soon as it's ready.
+ *
+ * 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 } },
+  },
+  // To enable defer and streaming, set to true.
+  // enableDeferStream: true,
+}

package/dist/commands/setup/realtime/templates/stream/alphabet/alphabet.sdl.template

@@ -0,0 +1,9 @@
+export const schema = gql`
+  type Query {
+    """
+    A field that spells out the letters of the alphabet
+    Maybe you want to @stream this field ;)
+    """
+    alphabet: [String!]! @skipAuth
+  }
+`

package/dist/commands/setup/realtime/templates/stream/alphabet/alphabet.ts.template

@@ -0,0 +1,31 @@
+import { Repeater } from '@cedarjs/realtime'
+
+import { logger } from 'src/lib/logger'
+
+export const alphabet = async () => {
+  return new Repeater<string>(async (push, stop) => {
+    const letters = 'abcdefghijklmnopqrstuvwxyz'.split('')
+
+    const publish = () => {
+      const letter = letters.shift()
+
+      if (letter) {
+        logger.debug({ letter }, 'publishing letter...')
+        push(letter)
+      }
+
+      if (letters.length === 0) {
+        stop()
+      }
+    }
+
+    const interval = setInterval(publish, 1000)
+
+    stop.then(() => {
+      logger.debug('cancel')
+      clearInterval(interval)
+    })
+
+    publish()
+  })
+}

package/dist/commands/setup/realtime/templates/subscriptions/countdown/countdown.ts.template

@@ -0,0 +1,58 @@
+import gql from 'graphql-tag'
+
+import { Repeater } from '@cedarjs/realtime'
+
+import { logger } from 'src/lib/logger'
+
+export const schema = gql`
+  type Subscription {
+    countdown(from: Int!, interval: Int!): Int! @requireAuth
+  }
+`
+
+/**
+ * To test this Countdown subscription, run the following in the GraphQL Playground:
+ *
+ * subscription CountdownFromInterval {
+ *   countdown(from: 100, interval: 10)
+ * }
+ */
+const countdown = {
+  countdown: {
+    subscribe: (
+      _,
+      {
+        from = 100,
+        interval = 10,
+      }: {
+        from: number
+        interval: number
+      }
+    ) =>
+      new Repeater((push, stop) => {
+        function decrement() {
+          from -= interval
+
+          if (from < 0) {
+            logger.debug({ from }, 'stopping as countdown is less than 0')
+            stop()
+          }
+
+          logger.debug({ from }, 'pushing countdown value ...')
+          push(from)
+        }
+
+        decrement()
+
+        const delay = setInterval(decrement, 500)
+
+        stop.then(() => {
+          clearInterval(delay)
+          logger.debug('stopping countdown')
+        })
+      }),
+    resolve: (payload: number) => payload,
+  },
+}
+
+export default countdown

package/dist/commands/setup/realtime/templates/subscriptions/newMessage/newMessage.ts.template

@@ -0,0 +1,57 @@
+import gql from 'graphql-tag'
+
+import type { PubSub } from '@cedarjs/realtime'
+
+import { logger } from 'src/lib/logger'
+
+export const schema = gql`
+  type Subscription {
+    newMessage(roomId: ID!): Message! @requireAuth
+  }
+`
+export type NewMessageChannel = {
+  newMessage: [roomId: string, payload: { from: string; body: string }]
+}
+
+export type NewMessageChannelType = PubSub<NewMessageChannel>
+
+/**
+ * To test this NewMessage subscription, run the following in one GraphQL Playground to subscribe:
+ *
+ * subscription ListenForNewMessagesInRoom {
+ *   newMessage(roomId: "1") {
+ *     body
+ *     from
+ *   }
+ * }
+ *
+ *
+ * And run the following in another GraphQL Playground to publish and send a message to the room:
+ *
+ * mutation SendMessageToRoom {
+ *   sendMessage(input: {roomId: "1", from: "hello", body: "bob"}) {
+ *     body
+ *     from
+ *   }
+ * }
+ */
+const newMessage = {
+  newMessage: {
+    subscribe: (
+      _,
+      { roomId },
+      { pubSub }: { pubSub: NewMessageChannelType }
+    ) => {
+      logger.debug({ roomId }, 'newMessage subscription')
+
+      return pubSub.subscribe('newMessage', roomId)
+    },
+    resolve: (payload) => {
+      logger.debug({ payload }, 'newMessage subscription resolve')
+
+      return payload
+    },
+  },
+}
+
+export default newMessage

package/dist/commands/setup/realtime/templates/subscriptions/newMessage/rooms.sdl.ts.template

@@ -0,0 +1,20 @@
+export const schema = gql`
+  type Message {
+    from: String
+    body: String
+  }
+
+  type Query {
+    room(id: ID!): [Message!]! @skipAuth
+  }
+
+  input SendMessageInput {
+    roomId: ID!
+    from: String!
+    body: String!
+  }
+
+  type Mutation {
+    sendMessage(input: SendMessageInput!): Message! @skipAuth
+  }
+`

package/dist/commands/setup/realtime/templates/subscriptions/newMessage/rooms.ts.template

@@ -0,0 +1,20 @@
+import type { SendMessageInput } from 'types/graphql'
+
+import type { NewMessageChannelType } from 'src/subscriptions/newMessage/newMessage'
+
+import { logger } from 'src/lib/logger'
+
+export const room = ({ id }) => [id]
+
+export const sendMessage = async (
+  { input }: { input: SendMessageInput },
+  { context }: { context: { pubSub: NewMessageChannelType } }
+) => {
+  logger.debug({ input }, 'sending message ....')
+
+  const { roomId, from, body } = input
+
+  context.pubSub.publish('newMessage', roomId, { from, body })
+
+  return input
+}