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

package/dist/commands/setup/ui/libraries/tailwindcssHandler.js

@@ -4,9 +4,15 @@ import { ListrEnquirerPromptAdapter } from "@listr2/prompt-adapter-enquirer";
 import execa from "execa";
 import { Listr } from "listr2";
 import { terminalLink } from "termi-link";
-import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { colors as c } from "@cedarjs/cli-helpers/colors";
+import { formatCedarCommand } from "@cedarjs/cli-helpers/packageManager/display";
+import { runBin } from "@cedarjs/cli-helpers/packageManager/exec";
+import {
+  addRootPackages,
+  addWorkspacePackages
+} from "@cedarjs/cli-helpers/packageManager/packages";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
 import { errorTelemetry } from "@cedarjs/telemetry";
-import c from "../../../../lib/colors.js";
 import { getPaths, usingVSCode } from "../../../../lib/index.js";
 const tailwindDirectives = [
   "@tailwind base;",
@@ -20,7 +26,7 @@ const tailwindImportsAndNotes = [
   "/**",
   " * START --- SETUP TAILWINDCSS EDIT",
   " *",
-  " * `yarn cedar setup ui tailwindcss` placed these directives here",
+  ` * \`${formatCedarCommand(["setup", "ui", "tailwindcss"])}\` placed these directives here`,
   " * to inject Tailwind's styles into your CSS.",
   " * For more information, see: https://tailwindcss.com/docs/installation",
   " */",
@@ -69,17 +75,19 @@ async function recommendExtensionsToInstall() {
     });
   }
 }
-const handler = async ({ force, install }) => {
+const handler = async ({
+  force,
+  install
+}) => {
   recordTelemetryAttributes({
     command: "setup ui tailwindcss",
     force,
     install
   });
   const rwPaths = getPaths();
-  const projectPackages = ["prettier-plugin-tailwindcss@^0.5.12"];
+  const projectPackages = ["prettier-plugin-tailwindcss@^0.8.0"];
   const webWorkspacePackages = [
     "postcss",
-    "postcss-loader",
     "tailwindcss@^3.4.17",
     "autoprefixer"
   ];
@@ -94,8 +102,9 @@ const handler = async ({ force, install }) => {
               {
                 title: `Install ${projectPackages.join(", ")}`,
                 task: async () => {
-                  await execa("yarn", ["add", "-D", ...projectPackages], {
-                    cwd: rwPaths.base
+                  await addRootPackages(projectPackages, {
+                    cwd: rwPaths.base,
+                    dev: true
                   });
                 }
               }
@@ -113,19 +122,16 @@ const handler = async ({ force, install }) => {
               {
                 title: `Install ${webWorkspacePackages.join(", ")}`,
                 task: async () => {
-                  await execa(
-                    "yarn",
-                    ["workspace", "web", "add", "-D", ...webWorkspacePackages],
-                    {
-                      cwd: rwPaths.base,
-                      env: {
-                        // For some reason yarn started installing deprecated
-                        // typescript types when installing tailwind. This
-                        // prevents it from happening.
-                        YARN_TS_ENABLE_AUTO_TYPES: "false"
-                      }
-                    }
-                  );
+                  await addWorkspacePackages("web", webWorkspacePackages, {
+                    cwd: rwPaths.base,
+                    env: {
+                      // For some reason yarn started installing deprecated
+                      // typescript types when installing tailwind. This
+                      // prevents it from happening. (yarn-only env var.)
+                      YARN_TS_ENABLE_AUTO_TYPES: "false"
+                    },
+                    dev: true
+                  });
                 }
               }
             ],
@@ -170,7 +176,7 @@ const handler = async ({ force, install }) => {
               );
             }
           }
-          await execa("yarn", ["tailwindcss", "init", tailwindConfigPath], {
+          await runBin("tailwindcss", ["init", tailwindConfigPath], {
             cwd: rwPaths.web.base
           });
           const tailwindConfig = fs.readFileSync(tailwindConfigPath, "utf-8");
@@ -235,7 +241,7 @@ const handler = async ({ force, install }) => {
             rwPaths.base,
             ".vscode/extensions.json"
           );
-          let originalExtensionsJson = { recommendations: [] };
+          let originalExtensionsJson = {};
           if (fs.existsSync(VS_CODE_EXTENSIONS_PATH)) {
             const originalExtensionsFile = fs.readFileSync(
               VS_CODE_EXTENSIONS_PATH,
@@ -246,7 +252,7 @@ const handler = async ({ force, install }) => {
           const newExtensionsJson = {
             ...originalExtensionsJson,
             recommendations: [
-              ...originalExtensionsJson.recommendations,
+              ...originalExtensionsJson.recommendations ?? [],
               ...recommendedVSCodeExtensions
             ]
           };
@@ -281,7 +287,10 @@ const handler = async ({ force, install }) => {
             const originalSettingsJson = JSON.parse(
               originalSettingsFile || "{}"
             );
-            const originalTwClassAttributesJson = originalSettingsJson["tailwindCSS.classAttributes"] || [];
+            const existingAttributes = originalSettingsJson["tailwindCSS.classAttributes"];
+            const originalTwClassAttributesJson = Array.isArray(
+              existingAttributes
+            ) ? existingAttributes : [];
             const mergedClassAttributes = Array.from(
               /* @__PURE__ */ new Set([...classAttributes, ...originalTwClassAttributesJson])
             );
@@ -343,7 +352,7 @@ const handler = async ({ force, install }) => {
             const pluginsMatch = newPrettierConfig.match(
               /plugins: \[[\sa-z\(\)'\-,]*]/
             );
-            const matched = pluginsMatch && pluginsMatch[0];
+            const matched = pluginsMatch != null ? pluginsMatch[0] : void 0;
             if (matched && (matched.includes("'prettier-plugin-tailwindcss'") || matched.includes('"prettier-plugin-tailwindcss"'))) {
               task.skip(
                 "tailwindcss-plugin-prettier already required in plugins"
@@ -371,9 +380,11 @@ const handler = async ({ force, install }) => {
     await tasks.run();
     await recommendExtensionsToInstall();
   } catch (e) {
-    errorTelemetry(process.argv, e.message);
-    console.error(c.error(e.message));
-    process.exit(e?.exitCode || 1);
+    const msg = e instanceof Error ? e.message : String(e);
+    const exitCode = e instanceof Error && "exitCode" in e && typeof e.exitCode === "number" ? e.exitCode : 1;
+    errorTelemetry(process.argv, msg);
+    console.error(c.error(msg));
+    process.exit(exitCode);
   }
 };
 export {

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

@@ -0,0 +1,41 @@
+const UPLOAD_MODEL = `model Upload {
+  id             String   @id @default(cuid())
+  /// Name of the storage target, as configured in api/src/lib/uploads
+  target         String
+  /// "pending" | "completed" | "failed"
+  status         String   @default("pending")
+  filename       String
+  mimeType       String
+  /// Bytes. BigInt because Int caps at 2 GB.
+  size           BigInt
+  /// Provider-specific reference: S3 object key, filename on disk, or null
+  /// for files stored inline
+  storageKey     String?
+  /// Inline bytes, only for DB targets
+  data           Bytes?
+  /// The user the file belongs to, when it belongs to one
+  userId         String?
+  /// Id of the upload token that created this row
+  tokenId        String?
+  /// The organization the file belongs to, in multi-tenant apps
+  organizationId String?
+  createdAt      DateTime @default(now())
+  updatedAt      DateTime @updatedAt
+}`;
+function hasModel(schema, modelName) {
+  return new RegExp(`\\bmodel\\s+${modelName}\\s*\\{`).test(schema);
+}
+function addUploadModel(schema) {
+  if (hasModel(schema, "Upload")) {
+    return schema;
+  }
+  return `${schema.trimEnd()}
+
+${UPLOAD_MODEL}
+`;
+}
+export {
+  UPLOAD_MODEL,
+  addUploadModel,
+  hasModel
+};

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

@@ -0,0 +1,151 @@
+const START_LINE = /^([ \t]*)await server\.start\(\)/m;
+const FACTORY_IMPORT = /import\s*\{[^}]*\bcreateAuthDecoder\b[^}]*\}\s*from\s*['"](@cedarjs\/auth-[a-z0-9-]+-api)['"]/;
+const DECODER_IMPORT = /import\s*\{[^}]*\bauthDecoder\b[^}]*\}\s*from\s*['"](@cedarjs\/auth-[a-z0-9-]+-api)['"]/;
+function detectServerAuth(graphqlSource) {
+  const factory = FACTORY_IMPORT.exec(graphqlSource);
+  if (factory) {
+    return { decoderPackage: factory[1], usesFactory: true };
+  }
+  const decoder = DECODER_IMPORT.exec(graphqlSource);
+  if (decoder) {
+    return { decoderPackage: decoder[1], usesFactory: false };
+  }
+  return null;
+}
+function importedBindings(source) {
+  const names = /* @__PURE__ */ new Set();
+  const statements = source.matchAll(
+    /^import\s+(type\s+)?([^;]*?)\s+from\s+['"][^'"]+['"]/gm
+  );
+  for (const [, typeOnly, clause] of statements) {
+    if (typeOnly) {
+      continue;
+    }
+    const braces = /\{([^}]*)\}/.exec(clause);
+    const defaultOrNamespace = clause.replace(/\{[^}]*\}/, "");
+    for (const part of defaultOrNamespace.split(",")) {
+      const local = part.replace(/^\s*\*\s+as\s+/, "").trim();
+      if (local) {
+        names.add(local);
+      }
+    }
+    for (const specifier of braces?.[1].split(",") ?? []) {
+      const trimmed = specifier.trim();
+      if (!trimmed || trimmed.startsWith("type ")) {
+        continue;
+      }
+      const alias = / as (\w+)$/.exec(trimmed);
+      names.add(alias ? alias[1] : trimmed);
+    }
+  }
+  return names;
+}
+function hasBinding(source, name) {
+  const declared = new RegExp(
+    `^(?:export\\s+)?(?:const|let|var|function)\\s+${name}\\b`,
+    "m"
+  );
+  return importedBindings(source).has(name) || declared.test(source);
+}
+function uploadsServerImports(source, auth) {
+  const packageSpecs = [];
+  const srcSpecs = [];
+  if (auth) {
+    if (auth.usesFactory) {
+      if (!hasBinding(source, "authDecoder")) {
+        packageSpecs.push({
+          names: ["createAuthDecoder"],
+          from: auth.decoderPackage
+        });
+      }
+    } else {
+      packageSpecs.push({ names: ["authDecoder"], from: auth.decoderPackage });
+    }
+  }
+  packageSpecs.push({
+    names: auth ? ["cedarUploadsPlugin", "createUploadAuthenticator"] : ["cedarUploadsPlugin"],
+    from: "@cedarjs/uploads"
+  });
+  if (auth) {
+    const authNames = ["getCurrentUser"];
+    if (auth.usesFactory && !hasBinding(source, "authDecoder")) {
+      authNames.unshift("cookieName");
+    }
+    srcSpecs.push({ names: authNames, from: "src/lib/auth" });
+  }
+  srcSpecs.push({ names: ["db"], from: "src/lib/db" });
+  srcSpecs.push({ names: ["targets"], from: "src/lib/uploads" });
+  const render = (specs) => specs.map((spec) => ({
+    ...spec,
+    names: spec.names.filter((name) => !hasBinding(source, name))
+  })).filter((spec) => spec.names.length > 0).map((spec) => `import { ${spec.names.join(", ")} } from '${spec.from}'`);
+  const packageLines = render(packageSpecs);
+  const srcLines = render(srcSpecs);
+  if (packageLines.length > 0 && srcLines.length > 0) {
+    return [...packageLines, "", ...srcLines];
+  }
+  return [...packageLines, ...srcLines];
+}
+function uploadsServerRegistration(source, auth) {
+  if (!auth) {
+    return `  await server.register(cedarUploadsPlugin, {
+    tokenSecret: process.env.UPLOAD_TOKEN_SECRET,
+    targets,
+    db,
+    // Once the app has auth, bind upload tokens to the logged-in user:
+    //
+    //   authenticate: createUploadAuthenticator({ authDecoder, getCurrentUser }),
+  })
+`;
+  }
+  const decoder = auth.usesFactory && !hasBinding(source, "authDecoder") ? "  const authDecoder = createAuthDecoder(cookieName)\n\n" : "";
+  return `${decoder}  await server.register(cedarUploadsPlugin, {
+    tokenSecret: process.env.UPLOAD_TOKEN_SECRET,
+    targets,
+    db,
+    // Binds upload tokens to the logged-in user through the same auth
+    // pipeline the GraphQL server uses
+    authenticate: createUploadAuthenticator({ authDecoder, getCurrentUser }),
+  })
+`;
+}
+function hasUploadsPlugin(source) {
+  return /^[ \t]*(?:(?:await|void)\s+|(?:const|let|var)\s+\w+\s*=\s*)?[\w.]+\.register\(\s*cedarUploadsPlugin\b/m.test(
+    source
+  );
+}
+function addUploadsPlugin(source, { auth = null } = {}) {
+  if (hasUploadsPlugin(source)) {
+    return source;
+  }
+  const start = START_LINE.exec(source);
+  if (!start) {
+    throw new Error("CEDAR_UPLOADS_ERR_NO_START");
+  }
+  const lines = source.split("\n");
+  let lastImport = -1;
+  for (const [index, line] of lines.entries()) {
+    if (/^import\s/.test(line)) {
+      lastImport = index;
+    }
+  }
+  const withImports = [
+    ...lines.slice(0, lastImport + 1),
+    ...uploadsServerImports(source, auth),
+    ...lines.slice(lastImport + 1)
+  ].join("\n");
+  return withImports.replace(
+    START_LINE,
+    (line) => `${uploadsServerRegistration(source, auth)}
+${line}`
+  );
+}
+export {
+  addUploadsPlugin,
+  detectServerAuth,
+  hasBinding,
+  hasUploadsPlugin,
+  importedBindings,
+  uploadsServerImports,
+  uploadsServerRegistration
+};

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

@@ -0,0 +1,15 @@
+import { createRequireUploadTokenDirective } from '@cedarjs/uploads'
+
+/**
+ * Requires a valid upload token in the x-upload-token request header and
+ * makes its claims available to the resolver through
+ * `getUploadTokenPayload(context)`. The token must have been issued to the
+ * requesting user.
+ */
+const requireUploadToken = createRequireUploadTokenDirective({
+  secret: process.env.UPLOAD_TOKEN_SECRET ?? '',
+})
+
+export const schema = requireUploadToken.schema
+
+export default requireUploadToken

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