@cedarjs/cli 7.0.1-next.467 → 7.1.0-rc.32

package/dist/commands/setup/uploads/templates/srcLibUploads.ts.template

@@ -1,24 +1,25 @@
-__PATH_IMPORT____S3_IMPORTS__import {
-  __FS_IMPORT__
-  __DB_IMPORT__
-  __DB_MAX_IMPORT__
-  defineStorageTargets,
-  defineUploadProfiles,
-} from '@cedarjs/uploads'
-__GET_PATHS_IMPORT__
-__S3_CLIENT__
-/**
- * Where files live. Each target is a provider instance; the Upload row
- * records which target holds a file so it can be read, served, and deleted
- * later. Look one up by name with `resolveTarget(targets, upload.target)`.
- */
-export const targets = defineStorageTargets({
-__TARGETS__})
+import { createUploadsConfig, setupStorage } from '@cedarjs/storage'
+import { FileSystemStorage } from '@cedarjs/storage/FileSystemStorage'
+import { UrlSigner } from '@cedarjs/storage/UrlSigner'
 
-/**
- * What clients may upload. A profile names a target and the constraints the
- * server signs into every upload token issued for it. The client never
- * supplies constraints; it names a profile.
- */
-export const profiles = defineUploadProfiles({
-__PROFILES__})
+const uploadsConfig = createUploadsConfig({
+  // Configure your fields here
+  // e.g. modelName: { fields: ['fieldWithUpload']}
+})
+
+export const fsStorage = new FileSystemStorage({
+  baseDir: './uploads',
+})
+
+export const urlSigner = new UrlSigner({
+  secret: process.env.UPLOADS_SECRET,
+  endpoint: '/signedUrl',
+})
+
+const { saveFiles, storagePrismaExtension } = setupStorage({
+  uploadsConfig,
+  storageAdapter: fsStorage,
+  urlSigner,
+})
+
+export { saveFiles, storagePrismaExtension }

package/dist/commands/setup/uploads/uploads.js

@@ -1,68 +1,26 @@
-import prompts from "prompts";
-import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
-import { requireTTYOrExit } from "@cedarjs/cli-helpers/tty";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
 const command = "uploads";
-const description = "Set up file uploads and storage: storage targets, upload profiles, the upload routes, and the GraphQL API";
-const TARGET_CHOICES = ["fs", "db", "s3"];
-const TARGET_DESCRIPTIONS = {
-  fs: "Local filesystem, uploaded through the api server (development, single-server deploys)",
-  db: "Inline in the database, for small files like avatars and thumbnails",
-  s3: "S3 or S3-compatible storage, uploaded straight from the browser with presigned URLs"
-};
+const description = "Setup uploads and storage. This will install the required packages and add the required initial configuration to your redwood app.";
 const builder = (yargs) => {
-  return yargs.option("targets", {
-    choices: TARGET_CHOICES,
-    description: "Storage targets to configure: fs (local filesystem), db (inline in the database), s3 (direct-to-S3 presigned uploads). Prompts when omitted.",
-    type: "array"
-  }).option("force", {
+  yargs.option("force", {
     alias: "f",
     default: false,
     description: "Overwrite existing configuration",
     type: "boolean"
   });
 };
-function toTargetChoices(values) {
-  const choices = TARGET_CHOICES;
-  return [...new Set(values)].filter(
-    (t) => choices.includes(t)
-  );
-}
-async function promptForTargets() {
-  requireTTYOrExit("--targets");
-  const response = await prompts({
-    type: "multiselect",
-    name: "targets",
-    message: "Which storage targets do you want to configure?",
-    instructions: false,
-    hint: "Space to toggle, enter to confirm",
-    min: 1,
-    choices: TARGET_CHOICES.map((value) => ({
-      title: value,
-      description: TARGET_DESCRIPTIONS[value],
-      value,
-      selected: value !== "s3"
-    }))
-  });
-  if (response.targets === void 0) {
-    process.exit(0);
-  }
-  return toTargetChoices(response.targets);
-}
 const handler = async (options) => {
-  const targets = options.targets?.length ? toTargetChoices(options.targets) : await promptForTargets();
   recordTelemetryAttributes({
     command: "setup uploads",
-    targets: targets.join(","),
-    force: options.force
+    force: options.force,
+    skipExamples: options.skipExamples
   });
   const { handler: handler2 } = await import("./uploadsHandler.js");
-  return handler2({ targets, force: options.force });
+  return handler2(options);
 };
 export {
-  TARGET_CHOICES,
   builder,
   command,
   description,
-  handler,
-  toTargetChoices
+  handler
 };

package/dist/commands/setup/uploads/uploadsHandler.js

@@ -1,298 +1,105 @@
 import fs from "node:fs";
 import path from "node:path";
-import { pathToFileURL } from "node:url";
 import { Listr } from "listr2";
 import { format } from "prettier";
 import { terminalLink } from "termi-link";
-import { colors as c } from "@cedarjs/cli-helpers/colors";
-import { getPrettierOptions } from "@cedarjs/cli-helpers/fileHelpers";
 import {
   addApiPackages,
-  addWebPackages
-} from "@cedarjs/cli-helpers/installHelpers";
+  getPrettierOptions,
+  colors as c
+} from "@cedarjs/cli-helpers";
 import { formatCedarCommand } from "@cedarjs/cli-helpers/packageManager/display";
-import { addEnvVar } from "@cedarjs/cli-helpers/project";
-import { getSchemaPath } from "@cedarjs/project-config";
 import { errorTelemetry } from "@cedarjs/telemetry";
 import { getPaths, transformTSToJS, writeFile } from "../../../lib/index.js";
 import { isTypeScriptProject } from "../../../lib/project.js";
-import { generateSecret } from "../../generate/secret/secret.js";
-import { setupServerFileTasks } from "../server-file/serverFileHandler.js";
-import { transformGitignore } from "./gitignore.js";
-import { addUploadModel } from "./schemaPrisma.js";
-import {
-  addUploadsPlugin,
-  detectServerAuth,
-  hasUploadsPlugin
-} from "./serverFile.js";
-const UPPY_VERSION = "^6.0.0";
-const S3_IMPORTS = `import { S3Client } from '@aws-sdk/client-s3'
-
-import { createS3Provider } from '@cedarjs/uploads/s3'
-`;
-const S3_CLIENT = `
-// Your own S3 client. It stays available for S3-specific work (lifecycle
-// rules, CORS, and so on) alongside the storage target below. Credentials
-// come from the SDK's default chain: AWS_ACCESS_KEY_ID and
-// AWS_SECRET_ACCESS_KEY in .env, or an IAM role, SSO, or container
-// credentials in production. For an S3-compatible service, add \`endpoint\`
-// and \`forcePathStyle: true\`.
-export const s3Client = new S3Client({
-  region: process.env.AWS_REGION,
-})
-
-const s3Bucket = process.env.S3_BUCKET_UPLOADS
-
-if (!s3Bucket) {
-  throw new Error('Set S3_BUCKET_UPLOADS in .env to use the S3 storage target')
-}
-`;
-const TARGET_BLOCKS = {
-  fs: `  // Files uploaded through the api server and stored on local disk. Good for
-  // development and single-server deploys.
-  local: createFsProvider({
-    uploadDir: path.join(getPaths().api.base, '.uploads'),
-    serveBaseUrl: process.env.UPLOAD_SERVE_BASE_URL,
-    signSecret: process.env.UPLOAD_TOKEN_SECRET,
-  }),
-`,
-  db: `  // Small files stored inline in the Upload row (avatars, thumbnails).
-  thumbnails: createDbProvider(),
-`,
-  s3: `  // Files uploaded straight from the browser to S3 with presigned URLs.
-  files: createS3Provider({
-    client: s3Client,
-    bucket: s3Bucket,
-    region: process.env.AWS_REGION,
-    keyPrefix: 'uploads/',
-  }),
-`
-};
-const PROFILE_BLOCKS = {
-  fs: `  attachment: {
-    target: 'local',
-    allowedMimeTypes: ['application/pdf', 'image/png', 'image/jpeg'],
-    maxFileSize: 25 * 1024 * 1024,
-    maxFiles: 10,
-  },
-`,
-  db: `  avatar: {
-    target: 'thumbnails',
-    allowedMimeTypes: ['image/png', 'image/jpeg'],
-    maxFileSize: DB_MAX_FILE_SIZE,
-    maxFiles: 1,
-  },
-`,
-  s3: `  document: {
-    target: 'files',
-    allowedMimeTypes: ['application/pdf', 'image/*'],
-    maxFileSize: 100 * 1024 * 1024,
-    maxFiles: 5,
-  },
-`
-};
-const handler = async ({ targets, force }) => {
-  const paths = getPaths();
+import { runTransform } from "../../../lib/runTransform.js";
+const handler = async ({ force }) => {
   const projectIsTypescript = isTypeScriptProject();
-  const ext = projectIsTypescript ? "ts" : "js";
-  const wantsFs = targets.includes("fs");
-  const wantsDb = targets.includes("db");
-  const wantsS3 = targets.includes("s3");
-  const wantsUppy = wantsFs || wantsS3;
-  const packageJson = await import(pathToFileURL(path.join(paths.base, "package.json")).href, { with: { type: "json" } });
+  const packageJson = await import(path.join(getPaths().base, "package.json"), {
+    with: { type: "json" }
+  });
   const cedarVersion = packageJson.default.devDependencies["@cedarjs/core"] ?? "latest";
-  const serverFilePath = path.join(paths.api.src, `server.${ext}`);
-  const writeTemplateFile = async (templateFile, outputPath, replacements = {}) => {
-    const templatePath = path.resolve(
-      import.meta.dirname,
-      "templates",
-      templateFile
-    );
-    let templateContent = fs.readFileSync(templatePath, "utf-8");
-    for (const [token, value] of Object.entries(replacements)) {
-      templateContent = templateContent.replaceAll(token, value);
-    }
-    const content = projectIsTypescript ? templateContent : await transformTSToJS(outputPath, templateContent);
-    return writeFile(outputPath, content, { overwriteExisting: force });
-  };
-  const apiPackages = [`@cedarjs/uploads@${cedarVersion}`];
-  const webPackages = [`@cedarjs/uploads@${cedarVersion}`];
-  if (wantsS3) {
-    apiPackages.push("@aws-sdk/client-s3", "@aws-sdk/s3-request-presigner");
-  }
-  if (wantsUppy) {
-    webPackages.push(
-      `@uppy/core@${UPPY_VERSION}`,
-      `@uppy/react@${UPPY_VERSION}`,
-      `@uppy/dashboard@${UPPY_VERSION}`
-    );
-  }
-  if (wantsFs) {
-    webPackages.push(`@uppy/xhr-upload@${UPPY_VERSION}`);
-  }
-  if (wantsS3) {
-    webPackages.push(`@uppy/aws-s3@${UPPY_VERSION}`);
-  }
   const tasks = new Listr(
     [
       {
-        ...addApiPackages(apiPackages),
-        title: "Adding @cedarjs/uploads to your api side..."
-      },
-      {
-        ...addWebPackages(webPackages),
-        title: "Adding @cedarjs/uploads to your web side..."
-      },
-      {
-        title: "Adding the Upload model to schema.prisma...",
+        title: `Adding api/src/lib/uploads.${projectIsTypescript ? "ts" : "js"}...`,
         task: async () => {
-          const schemaPath = await getSchemaPath(paths.api.prismaConfig);
-          const schema = fs.readFileSync(schemaPath, "utf-8");
-          fs.writeFileSync(schemaPath, addUploadModel(schema));
-        }
-      },
-      {
-        title: `Adding api/src/lib/uploads.${ext}...`,
-        task: async () => {
-          await writeTemplateFile(
-            "srcLibUploads.ts.template",
-            path.join(paths.api.lib, `uploads.${ext}`),
-            {
-              __S3_IMPORTS__: wantsS3 ? S3_IMPORTS : "",
-              __S3_CLIENT__: wantsS3 ? S3_CLIENT : "",
-              __FS_IMPORT__: wantsFs ? "createFsProvider," : "",
-              __DB_IMPORT__: wantsDb ? "createDbProvider," : "",
-              __DB_MAX_IMPORT__: wantsDb ? "DB_MAX_FILE_SIZE," : "",
-              __PATH_IMPORT__: wantsFs ? "import path from 'node:path'\n\n" : "",
-              __GET_PATHS_IMPORT__: wantsFs ? "import { getPaths } from '@cedarjs/project-config'\n" : "",
-              __TARGETS__: targets.map((t) => TARGET_BLOCKS[t]).join("\n"),
-              __PROFILES__: targets.map((t) => PROFILE_BLOCKS[t]).join("\n")
-            }
+          const templatePath = path.resolve(
+            import.meta.dirname,
+            "templates",
+            "srcLibUploads.ts.template"
+          );
+          const templateContent = fs.readFileSync(templatePath, {
+            encoding: "utf8",
+            flag: "r"
+          });
+          const uploadsPath = path.join(
+            getPaths().api.lib,
+            `uploads.${projectIsTypescript ? "ts" : "js"}`
           );
+          const uploadsContent = projectIsTypescript ? templateContent : await transformTSToJS(uploadsPath, templateContent);
+          return writeFile(uploadsPath, uploadsContent, {
+            overwriteExisting: force
+          });
         }
       },
       {
-        title: "Adding the uploads SDL and service...",
+        title: `Adding signedUrl function...`,
         task: async () => {
-          await writeTemplateFile(
-            "uploads.sdl.ts.template",
-            path.join(paths.api.graphql, `uploads.sdl.${ext}`)
+          const templatePath = path.resolve(
+            import.meta.dirname,
+            "templates",
+            "signedUrl.ts.template"
           );
-          await writeTemplateFile(
-            "uploads.ts.template",
-            path.join(paths.api.services, "uploads", `uploads.${ext}`)
+          const templateContent = fs.readFileSync(templatePath, {
+            encoding: "utf8",
+            flag: "r"
+          });
+          const uploadsPath = path.join(
+            getPaths().api.functions,
+            `signedUrl.${projectIsTypescript ? "ts" : "js"}`
           );
+          const uploadsContent = projectIsTypescript ? templateContent : await transformTSToJS(uploadsPath, templateContent);
+          return writeFile(uploadsPath, uploadsContent, {
+            overwriteExisting: force
+          });
         }
       },
       {
-        title: "Adding the upload directives...",
-        task: async () => {
-          const directives = ["requireUploadToken", "withSignedUrl"];
-          if (wantsDb) {
-            directives.push("withDataUri");
-          }
-          for (const name of directives) {
-            await writeTemplateFile(
-              `${name}.ts.template`,
-              path.join(paths.api.directives, name, `${name}.${ext}`)
-            );
-          }
-        }
-      },
-      {
-        title: "Adding the server file...",
-        task: (_ctx, task) => task.newListr(setupServerFileTasks({ force: false })),
-        skip: () => fs.existsSync(serverFilePath) ? "api/src/server already exists; skipping." : false
-      },
-      {
-        title: "Registering the upload plugin in api/src/server...",
-        task: async (_ctx, task) => {
-          const source = fs.readFileSync(serverFilePath, "utf-8");
-          if (hasUploadsPlugin(source)) {
-            task.skip("The upload plugin is already registered; skipping.");
-            return;
-          }
-          const graphqlPath = path.join(paths.api.functions, `graphql.${ext}`);
-          const authPath = path.join(paths.api.lib, `auth.${ext}`);
-          const auth = fs.existsSync(graphqlPath) && fs.existsSync(authPath) && fs.readFileSync(authPath, "utf-8").includes("getCurrentUser") ? detectServerAuth(fs.readFileSync(graphqlPath, "utf-8")) : null;
-          let updated;
-          try {
-            updated = addUploadsPlugin(source, { auth });
-          } catch {
-            throw new Error(
-              `Could not find \`await server.start()\` in ${path.relative(
-                paths.base,
-                serverFilePath
-              )}. Register the plugin by hand before the server starts:
-
-  import { cedarUploadsPlugin } from '@cedarjs/uploads'
-  import { db } from 'src/lib/db'
-  import { targets } from 'src/lib/uploads'
-
-  await server.register(cedarUploadsPlugin, {
-    tokenSecret: process.env.UPLOAD_TOKEN_SECRET,
-    targets,
-    db,
-  })
-`
-            );
-          }
-          fs.writeFileSync(serverFilePath, updated);
-        }
+        ...addApiPackages([`@cedarjs/storage@${cedarVersion}`]),
+        title: "Adding dependencies to your api side..."
       },
       {
-        title: "Adding environment variables to .env...",
-        task: () => {
-          addEnvVar(
-            "UPLOAD_TOKEN_SECRET",
-            generateSecret(),
-            "Signs upload tokens and file-serving URLs. Keep it secret and use a different value per environment."
+        title: "Modifying api/src/lib/db to add uploads prisma extension..",
+        task: async () => {
+          const dbPath = path.join(
+            getPaths().api.lib,
+            `db.${projectIsTypescript ? "ts" : "js"}`
           );
-          if (wantsFs) {
-            addEnvVar(
-              "UPLOAD_SERVE_BASE_URL",
-              "http://localhost:8911",
-              "Origin the api server is reachable at, used to build signed URLs for locally stored files."
-            );
-          }
-          if (wantsS3) {
-            addEnvVar(
-              "AWS_REGION",
-              "us-east-1",
-              "Region of the uploads bucket."
-            );
-            addEnvVar("AWS_ACCESS_KEY_ID", "replace-me", "");
-            addEnvVar("AWS_SECRET_ACCESS_KEY", "replace-me", "");
-            addEnvVar(
-              "S3_BUCKET_UPLOADS",
-              "replace-me",
-              "Bucket direct uploads land in."
+          const transformResult = await runTransform({
+            transformPath: path.join(import.meta.dirname, "dbCodemod.js"),
+            targetPaths: [dbPath]
+          });
+          if (transformResult.error) {
+            if (transformResult.error === "RW_CODEMOD_ERR_OLD_FORMAT") {
+              throw new Error(
+                "It looks like your src/lib/db file is using the old format. Please update it as per the v8 upgrade guide: https://cedarjs.com/docs/8.x/upgrade-guides/v8#database-file-structure-change. And run again. \n\nYou can also manually modify your api/src/lib/db to include the prisma extension: https://cedarjs.com/docs/uploads/#attaching-the-prisma-extension"
+              );
+            }
+            throw new Error(
+              "Could not add the prisma extension. \n Please modify your api/src/lib/db to include the prisma extension: https://cedarjs.com/docs/uploads/#attaching-the-prisma-extension"
             );
           }
         }
       },
-      {
-        title: "Adding the fs upload directory to .gitignore...",
-        skip: () => wantsFs ? false : "No fs target selected; skipping.",
-        task: (_ctx, task) => {
-          const gitignorePath = path.join(paths.base, ".gitignore");
-          const source = fs.existsSync(gitignorePath) ? fs.readFileSync(gitignorePath, "utf-8") : "";
-          const updated = transformGitignore(source);
-          if (updated === source) {
-            task.skip(".gitignore already up to date");
-            return;
-          }
-          fs.writeFileSync(gitignorePath, updated, "utf-8");
-        }
-      },
       {
         title: "Prettifying changed files",
         task: async (_ctx, task) => {
           const prettifyPaths = [
-            serverFilePath,
-            path.join(paths.api.lib, `uploads.${ext}`),
-            path.join(paths.api.graphql, `uploads.sdl.${ext}`),
-            path.join(paths.api.services, "uploads", `uploads.${ext}`)
+            path.join(getPaths().api.lib, "db.js"),
+            path.join(getPaths().api.lib, "db.ts"),
+            path.join(getPaths().api.lib, "uploads.js"),
+            path.join(getPaths().api.lib, "uploads.ts")
           ];
           for (const prettifyPath of prettifyPaths) {
             try {
@@ -301,11 +108,11 @@ const handler = async ({ targets, force }) => {
               }
               const source = fs.readFileSync(prettifyPath, "utf-8");
               const prettierOptions = await getPrettierOptions();
-              const prettified = await format(source, {
+              const prettifiedApp = await format(source, {
                 ...prettierOptions,
                 parser: "babel-ts"
               });
-              fs.writeFileSync(prettifyPath, prettified, "utf-8");
+              fs.writeFileSync(prettifyPath, prettifiedApp, "utf-8");
             } catch {
               task.output = "Couldn't prettify the changes. Please reformat the files manually if needed.";
             }
@@ -315,30 +122,15 @@ const handler = async ({ targets, force }) => {
       {
         title: "One more thing...",
         task: (_ctx, task) => {
-          const migrate = c.highlight(
-            formatCedarCommand(["prisma", "migrate", "dev"])
-          );
-          const types = c.highlight(formatCedarCommand(["generate", "types"]));
           task.title = `One more thing...
 
-          ${c.success("Uploads configured!")}
-
-          Next steps:
+          ${c.success("\nUploads and storage configured!\n")}
 
-            1. Apply the schema change: ${migrate}
-            2. Regenerate types: ${types}
-            3. Review the storage targets and upload profiles in api/src/lib/uploads.${ext}${wantsS3 ? "\n            4. Fill in the AWS_* and S3_BUCKET_UPLOADS values in .env" : ""}
-
-          Upload tokens are bound to the logged-in user when the app has auth.
-          If you add auth later, pass
-          \`authenticate: createUploadAuthenticator({ authDecoder, getCurrentUser })\`
-          to the plugin in api/src/server.${ext}.
-
-          Schedule cleanupStaleUploads() from a recurring job to sweep uploads
-          that never completed.
+          Remember to add UPLOADS_SECRET to your .env file. You can generate one with ${c.highlight(formatCedarCommand(["generate", "secret"]))}
 
           Check out the docs for more info:
           ${terminalLink("", "https://cedarjs.com/docs/uploads")}
+
         `;
         }
       }

package/dist/commands/setup.js

@@ -16,12 +16,11 @@ import * as setupNeon from "./setup/neon/neon.js";
 import * as setupPackage from "./setup/package/package.js";
 import * as setupRealtime from "./setup/realtime/realtime.js";
 import * as setupServerFile from "./setup/server-file/serverFile.js";
-import * as setupTenancy from "./setup/tenancy/tenancy.js";
 import * as setupUi from "./setup/ui/ui.js";
 import * as setupUploads from "./setup/uploads/uploads.js";
 const command = "setup <command>";
 const description = "Initialize project config and install packages";
-const builder = (yargs) => yargs.command(setupAuth).command(setupCache).command(setupDatabase).command(setupDeploy).command(setupDocker).command(setupGenerator).command(setupGraphql).command(setupI18n).command(setupJobs).command(setupMailer).command(setupMiddleware).command(setupMonitoring).command(setupNeon).command(setupPackage).command(setupRealtime).command(setupServerFile).command(setupTenancy).command(setupUi).command(setupUploads).demandCommand().middleware(detectCedarVersion).epilogue(
+const builder = (yargs) => yargs.command(setupAuth).command(setupCache).command(setupDatabase).command(setupDeploy).command(setupDocker).command(setupGenerator).command(setupGraphql).command(setupI18n).command(setupJobs).command(setupMailer).command(setupMiddleware).command(setupMonitoring).command(setupNeon).command(setupPackage).command(setupRealtime).command(setupServerFile).command(setupUi).command(setupUploads).demandCommand().middleware(detectCedarVersion).epilogue(
   `Also see the ${terminalLink(
     "CedarJS CLI Reference",
     "https://cedarjs.com/docs/cli-commands#setup"

package/dist/commands/studio.js

@@ -1,4 +1,4 @@
-import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
 const command = "studio";
 const description = "Run the CedarJS development studio";
 function builder(yargs) {