@cedarjs/cli 7.0.0 → 8.0.0-canary.3263

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

@@ -1,25 +1,24 @@
-import { createUploadsConfig, setupStorage } from '@cedarjs/storage'
-import { FileSystemStorage } from '@cedarjs/storage/FileSystemStorage'
-import { UrlSigner } from '@cedarjs/storage/UrlSigner'
+__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__})
 
-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 }
+/**
+ * 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__})

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

@@ -0,0 +1,79 @@
+export const schema = gql`
+  type Upload {
+    id: String!
+    target: String!
+    status: String!
+    filename: String!
+    mimeType: String!
+    size: BigInt!
+    storageKey: String
+    userId: String
+    organizationId: String
+    createdAt: DateTime!
+    updatedAt: DateTime!
+  }
+
+  type UploadToken {
+    token: String!
+    """
+    The profile's constraints, echoed for client-side UX (file-picker
+    filters, pre-upload validation). The authoritative copy is inside the
+    signed token.
+    """
+    allowedMimeTypes: [String!]!
+    maxFileSize: BigInt!
+    maxFiles: Int!
+  }
+
+  type PresignedUploadUrl {
+    uploadId: String!
+    url: String!
+    method: String!
+    headers: JSON!
+  }
+
+  input CreatePresignedUploadUrlInput {
+    filename: String!
+    contentType: String!
+    size: BigInt!
+  }
+
+  input UploadFileInput {
+    filename: String!
+    mimeType: String!
+    """
+    The file's bytes, base64-encoded. Only for profiles whose target stores
+    files inline in the database.
+    """
+    data: String!
+  }
+
+  type Query {
+    """
+    Issues an upload token for a server-defined profile. The profile name
+    must match a key of \`profiles\` in api/src/lib/uploads.
+    """
+    requestUploadToken(profile: String!): UploadToken! @requireAuth
+  }
+
+  type Mutation {
+    """
+    Direct-to-storage uploads: returns a presigned URL for one file. Send the
+    upload token in the x-upload-token header.
+    """
+    createPresignedUploadUrl(
+      input: CreatePresignedUploadUrlInput!
+    ): PresignedUploadUrl! @requireAuth @requireUploadToken
+
+    """
+    Confirms a direct-to-storage upload once the client has PUT the bytes.
+    """
+    confirmUpload(uploadId: String!): Upload! @requireAuth
+
+    """
+    Stores a small file sent as base64, for profiles whose target keeps files
+    inline in the database.
+    """
+    uploadFile(profile: String!, input: UploadFileInput!): Upload! @requireAuth
+  }
+`

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

@@ -0,0 +1,89 @@
+import {
+  confirmUpload as confirmUploadRecord,
+  createPresignedUpload,
+  getUploadTokenPayload,
+  isMimeTypeAllowed,
+  issueUploadToken,
+  resolveProfile,
+  resolveTarget,
+  storeFile,
+  UploadError,
+} from '@cedarjs/uploads'
+
+import { db } from 'src/lib/db'
+import { profiles, targets } from 'src/lib/uploads'
+
+const secret = () => {
+  if (!process.env.UPLOAD_TOKEN_SECRET) {
+    throw new Error(
+      'UPLOAD_TOKEN_SECRET is not set. Generate one with `yarn cedar generate secret` and add it to .env.',
+    )
+  }
+
+  return process.env.UPLOAD_TOKEN_SECRET
+}
+
+export const requestUploadToken = ({ profile }: { profile: string }) => {
+  return issueUploadToken({
+    profiles,
+    profile,
+    secret: secret(),
+    currentUser: context.currentUser,
+  })
+}
+
+export const createPresignedUploadUrl = ({
+  input,
+}: {
+  input: { filename: string; contentType: string; size: bigint | number }
+}) => {
+  return createPresignedUpload({
+    db,
+    targets,
+    tokenPayload: getUploadTokenPayload(context),
+    input,
+  })
+}
+
+export const confirmUpload = ({ uploadId }: { uploadId: string }) => {
+  return confirmUploadRecord({
+    db,
+    targets,
+    uploadId,
+    currentUser: context.currentUser,
+  })
+}
+
+export const uploadFile = async ({
+  profile: profileName,
+  input,
+}: {
+  profile: string
+  input: { filename: string; mimeType: string; data: string }
+}) => {
+  const profile = resolveProfile(profiles, profileName)
+  const target = resolveTarget(targets, profile.target)
+
+  if (target.providerType !== 'db') {
+    throw new UploadError(
+      'NOT_SUPPORTED',
+      `Upload profile '${profile.name}' does not store files in the database. Use an upload token instead.`,
+    )
+  }
+
+  if (!isMimeTypeAllowed(profile.allowedMimeTypes, input.mimeType)) {
+    throw new UploadError(
+      'MIME_TYPE_NOT_ALLOWED',
+      `File type '${input.mimeType}' is not allowed for upload profile '${profile.name}'.`,
+    )
+  }
+
+  return storeFile(target, {
+    db,
+    filename: input.filename,
+    mimeType: input.mimeType,
+    data: Buffer.from(input.data, 'base64'),
+    maxSize: profile.maxFileSize,
+    userId: context.currentUser ? String(context.currentUser.id) : undefined,
+  })
+}

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

@@ -0,0 +1,14 @@
+import { createWithDataUriDirective } from '@cedarjs/uploads'
+
+import { db } from 'src/lib/db'
+import { targets } from 'src/lib/uploads'
+
+/**
+ * Resolves a field holding an Upload id to a base64 data: URI of the file.
+ * Every resolved field embeds the whole file, so use it for small files only.
+ */
+const withDataUri = createWithDataUriDirective({ db, targets })
+
+export const schema = withDataUri.schema
+
+export default withDataUri

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

@@ -0,0 +1,16 @@
+import { createWithSignedUrlDirective } from '@cedarjs/uploads'
+
+import { db } from 'src/lib/db'
+import { targets } from 'src/lib/uploads'
+
+/**
+ * Resolves a field holding an Upload id to a time-limited URL for the file,
+ * from whichever storage target holds it. Files download by default; pass
+ * `disposition: 'inline'` to render them in the browser instead, and only
+ * for MIME types you trust.
+ */
+const withSignedUrl = createWithSignedUrlDirective({ db, targets })
+
+export const schema = withSignedUrl.schema
+
+export default withSignedUrl

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

@@ -1,26 +1,68 @@
-import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import prompts from "prompts";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
+import { requireTTYOrExit } from "@cedarjs/cli-helpers/tty";
 const command = "uploads";
-const description = "Setup uploads and storage. This will install the required packages and add the required initial configuration to your redwood app.";
+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 builder = (yargs) => {
-  yargs.option("force", {
+  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", {
     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",
-    force: options.force,
-    skipExamples: options.skipExamples
+    targets: targets.join(","),
+    force: options.force
   });
   const { handler: handler2 } = await import("./uploadsHandler.js");
-  return handler2(options);
+  return handler2({ targets, force: options.force });
 };
 export {
+  TARGET_CHOICES,
   builder,
   command,
   description,
-  handler
+  handler,
+  toTargetChoices
 };