@cedarjs/cli 7.0.1-next.333 → 7.0.1-next.467

package/dist/commands/generate/scaffold/templates/assets/scaffold.tailwind.css.template

@@ -1,3 +1,9 @@
+/**
+ * Makes your app's Tailwind theme and utilities available to `@apply`
+ * without emitting any of the styles in index.css a second time
+ */
+@reference './index.css';
+
 .rw-scaffold {
   @apply bg-white text-gray-600;
 }
@@ -27,8 +33,7 @@
   @apply mx-4 pb-4;
 }
 .rw-segment {
-  @apply rounded-lg overflow-hidden w-full border border-gray-200;
-  scrollbar-color: theme('colors.zinc.400') transparent;
+  @apply rounded-lg overflow-hidden w-full border border-gray-200 scrollbar-thumb-zinc-400 scrollbar-track-transparent;
 }
 .rw-segment::-webkit-scrollbar {
   height: initial;
@@ -80,7 +85,7 @@
 }
 .rw-cell-error,
 .rw-form-error-wrapper {
-  @apply p-4 bg-red-50 text-red-600 border border-red-100 rounded my-4;
+  @apply p-4 bg-red-50 text-red-600 border border-red-100 rounded-sm my-4;
 }
 .rw-form-error-title {
   @apply m-0 font-semibold;
@@ -89,13 +94,13 @@
   @apply mt-2 list-disc list-inside;
 }
 .rw-button {
-  @apply flex justify-center py-1 px-4 border-0 rounded bg-gray-200 text-gray-500 text-xs font-semibold uppercase tracking-wide leading-loose no-underline cursor-pointer transition duration-100;
+  @apply flex justify-center py-1 px-4 border-0 rounded-sm bg-gray-200 text-gray-500 text-xs font-semibold uppercase tracking-wide leading-loose no-underline cursor-pointer transition duration-100;
 }
 .rw-button:hover {
   @apply bg-gray-500 text-white;
 }
 .rw-button.rw-button-small {
-  @apply text-xs rounded-sm py-1 px-2;
+  @apply text-xs rounded-xs py-1 px-2;
 }
 .rw-button.rw-button-green {
   @apply bg-green-500 text-white;
@@ -134,7 +139,7 @@
   @apply text-red-600;
 }
 .rw-input {
-  @apply block mt-2 w-full p-2 bg-white border border-gray-200 rounded outline-none;
+  @apply block mt-2 w-full p-2 bg-white border border-gray-200 rounded-sm outline-hidden;
 }
 .rw-check-radio-items {
   @apply flex justify-items-center;
@@ -153,7 +158,7 @@
   @apply border-red-600 text-red-600;
 }
 .rw-input-error:focus {
-  @apply border-red-600 outline-none;
+  @apply border-red-600 outline-hidden;
   box-shadow: 0 0 5px #c53030;
 }
 .rw-field-error {

package/dist/commands/generate/scaffold/templates/components/EditNameCell.tsx.template

@@ -1,6 +1,7 @@
 ${useClientDirective}import type {
   Edit${singularPascalName}By${pascalIdName},
   Update${singularPascalName}Input,
+  Update${singularPascalName}Mutation,
   Update${singularPascalName}MutationVariables
 } from 'types/graphql'
 
@@ -24,7 +25,7 @@ export const QUERY: TypedDocumentNode<Edit${singularPascalName}By${pascalIdName}
 `
 
 const UPDATE_${singularConstantName}_MUTATION: TypedDocumentNode<
-  Edit${singularPascalName}ById,
+  Update${singularPascalName}Mutation,
   Update${singularPascalName}MutationVariables
 > = gql`
   mutation Update${singularPascalName}Mutation($${idName}: ${idType}!, $input: Update${singularPascalName}Input!) {
@@ -36,6 +37,8 @@ const UPDATE_${singularConstantName}_MUTATION: TypedDocumentNode<
 
 export const Loading = () => <div>Loading...</div>
 
+export const Empty = () => <div>${singularPascalName} not found</div>
+
 export const Failure = ({ error }: CellFailureProps) => (
   <div className="rw-cell-error">{error?.message}</div>
 )
@@ -54,17 +57,14 @@ export const Success = ({ ${singularCamelName} }: CellSuccessProps<Edit${singula
     }
   )
 
-  const onSave = (
-    input: Update${singularPascalName}Input,
-    id: Edit${singularPascalName}By${pascalIdName}['${singularCamelName}']['id']
-  ) => {
-    update${singularPascalName}({ variables: { id, input } })
+  const onSave = (input: Update${singularPascalName}Input) => {
+    update${singularPascalName}({ variables: { ${idName}: ${singularCamelName}.${idName}, input } })
   }
 
   return (
     <div className="rw-segment">
       <header className="rw-segment-header">
-        <h2 className="rw-heading rw-heading-secondary">Edit ${singularPascalName} {${singularCamelName}?.id}</h2>
+        <h2 className="rw-heading rw-heading-secondary">Edit ${singularPascalName} {${singularCamelName}.${idName}}</h2>
       </header>
       <div className="rw-segment-main">
         <${singularPascalName}Form ${singularCamelName}={${singularCamelName}} onSave={onSave} error={error} loading={loading} />

package/dist/commands/generate/scaffold/templates/components/NameForm.tsx.template

@@ -1,4 +1,4 @@
-import type { Edit${singularPascalName}By${pascalIdName}, Update${singularPascalName}Input } from 'types/graphql'
+import type { Edit${singularPascalName}By${pascalIdName}, Create${singularPascalName}Input } from 'types/graphql'
 
 import type { RWGqlError } from '@cedarjs/forms'
 import {
@@ -48,8 +48,8 @@ type Form${singularPascalName} = NonNullable<Edit${singularPascalName}By${pascal
 
 interface ${singularPascalName}FormProps {
   ${singularCamelName}?: Edit${singularPascalName}By${pascalIdName}['${singularCamelName}']
-  onSave: (data: Update${singularPascalName}Input, ${idName}?: Form${singularPascalName}['${idName}']) => void
-  error: RWGqlError
+  onSave: (data: Create${singularPascalName}Input) => void
+  error?: RWGqlError
   loading: boolean
 }
 
@@ -70,7 +70,8 @@ const ${singularPascalName}Form = (props: ${singularPascalName}FormProps) => {
       }
     <% } %>
     <% if (column.isEnum && !column.isList && !column.isRequired) { %>
-      if (data.${column.name} === '') {
+      // The "None" option has an empty value
+      if (!data.${column.name}) {
         data.${column.name} = null
       }
     <% } %>
@@ -80,7 +81,7 @@ const ${singularPascalName}Form = (props: ${singularPascalName}FormProps) => {
       }
     <% } %>
   <% }) %>
-    props.onSave(data, props?.${singularCamelName}?.${idName})
+    props.onSave(data)
   }
 
   return (
@@ -136,7 +137,7 @@ const ${singularPascalName}Form = (props: ${singularPascalName}FormProps) => {
         <% } else { %>
           <${column.component}
             name="${column.name}"
-            ${column.defaultProp}={${column.deserializeFunction && column.deserializeFunction + '('}props.${singularCamelName}?.<%= column.name %>${column.deserializeFunction && ')'}}
+            ${column.defaultProp}={${column.deserializeFunction && column.deserializeFunction + '('}props.${singularCamelName}?.<%= column.name %>${column.deserializeFunction && ')'}<%= !column.deserializeFunction && !column.isRequired ? ' ?? undefined' : '' %>}
             className="rw-input"
             errorClassName="rw-input rw-input-error"
             <%= !column.validation ? '' : `validation=${column.validation}` %>

package/dist/commands/generate/scaffold/templates/layouts/NamesScaffoldLayout.tsx.template

@@ -0,0 +1,18 @@
+import type { WrapperProps } from '@cedarjs/router'
+
+import ScaffoldLayout from '${importLayoutNames}'
+
+function ${pluralPascalName}ScaffoldLayout({ children }: WrapperProps) {
+  return (
+    <ScaffoldLayout
+      title="${pluralPascalName}"
+      titleTo="${pluralRouteName}"
+      buttonLabel="New ${singularPascalName}"
+      buttonTo="${newRouteName}"
+    >
+      {children}
+    </ScaffoldLayout>
+  )
+}
+
+export default ${pluralPascalName}ScaffoldLayout

package/dist/commands/generate/scaffold/templates/lib/formatters.tsx.template

@@ -25,7 +25,7 @@ export const jsonDisplay = (obj: unknown) => {
   )
 }
 
-export const truncate = (value: string | number) => {
+export const truncate = (value: string | number | null | undefined) => {
   let output = value?.toString() ?? ''
 
   if (output.length > MAX_STRING_LENGTH) {
@@ -65,6 +65,6 @@ export function timeTag(dateTime: <%= parsedDateTime ? 'Date' : 'string' %> | un
   return output
 }
 
-export const checkboxInputTag = (checked: boolean) => {
-  return <input type="checkbox" checked={checked} disabled />
+export const checkboxInputTag = (checked: boolean | null | undefined) => {
+  return <input type="checkbox" checked={!!checked} disabled />
 }

package/dist/commands/generate/script/templates/tsconfig.json.template

@@ -2,6 +2,7 @@
   "compilerOptions": {
     "noEmit": true,
     "allowJs": true,
+    "strict": true,
     "esModuleInterop": true,
     "baseUrl": "./",
     "rootDirs": [

package/dist/commands/generate/sdl/sdlHandler.js

@@ -19,7 +19,11 @@ import {
   getEnum,
   verifyModelName
 } from "../../../lib/schemaHelpers.js";
-import { redactedModelFields, relationsForModel } from "../helpers.js";
+import {
+  DEFAULT_IGNORE_FIELDS_FOR_INPUT,
+  redactedModelFields,
+  relationsForModel
+} from "../helpers.js";
 import { files as serviceFiles } from "../service/serviceHandler.js";
 import { templateForFile } from "../yargsHandlerHelpers.js";
 import {
@@ -27,7 +31,6 @@ import {
   missingRelatedModels,
   writeFilesWithStubsTask
 } from "./stubFiles.js";
-const DEFAULT_IGNORE_FIELDS_FOR_INPUT = ["createdAt", "updatedAt"];
 const missingIdConsoleMessage = () => {
   const line1 = ansis.bold.yellow("WARNING") + ": Cannot generate CRUD SDL without an `@id` database column.";
   const line2 = "If you are trying to generate for a many-to-many join table ";
@@ -61,7 +64,8 @@ const modelFieldToSDL = ({
     Bytes: "Byte"
   };
   const gqlType = prismaTypeToGraphqlType[field.type] || field.type;
-  const type = field.isList ? `[${gqlType}]` : gqlType;
+  const listItemType = field.kind === "object" ? gqlType : `${gqlType}!`;
+  const type = field.isList ? `[${listItemType}]` : gqlType;
   const isRequired = field.isRequired && required || field.isList || field.isId;
   const fieldContent = `${field.name}: ${type}${isRequired ? "!" : ""}`;
   if (docs) {
@@ -332,6 +336,7 @@ const handler = async ({
 export {
   files,
   handler,
+  modelFieldToSDL,
   printRedactedFieldsNote,
   redactedSensitiveFields,
   stubFiles

package/dist/commands/generate/service/serviceHandler.js

@@ -3,7 +3,14 @@ import camelcase from "camelcase";
 import { pluralize, singularize } from "@cedarjs/utils/cedarPluralize";
 import { transformTSToJS } from "../../../lib/index.js";
 import { getSchema, verifyModelName } from "../../../lib/schemaHelpers.js";
-import { redactedModelFields, relationsForModel } from "../helpers.js";
+import {
+  DEFAULT_IGNORE_FIELDS_FOR_INPUT,
+  nullableJsonFieldsInInput,
+  nullableRelationsForModel,
+  redactedModelFields,
+  relationsForModel,
+  requiredFieldsInUpdateInput
+} from "../helpers.js";
 import { createHandler, templateForFile } from "../yargsHandlerHelpers.js";
 function isServiceModel(schema) {
   return typeof schema === "object" && schema !== null && "fields" in schema && "name" in schema;
@@ -59,11 +66,13 @@ function scenarioFieldValue(field) {
       return randInt;
     case "Json":
       return { foo: "bar" };
-    case "String":
+    case "String": {
+      const isUnique = field.isUnique || field.isId;
       if (field.name?.toLowerCase().includes("email")) {
-        return field.isUnique ? `foo${randInt}@bar.com` : "foo@bar.com";
+        return isUnique ? `foo${randInt}@bar.com` : "foo@bar.com";
       }
-      return field.isUnique ? `String${randInt}` : "String";
+      return isUnique ? `String${randInt}` : "String";
+    }
     case "Bytes":
       return `new Uint8Array([${randIntArray}])`;
     default: {
@@ -152,11 +161,14 @@ const fieldsToInput = async (model) => {
   const modelName = camelcase(singularize(model));
   const inputObj = {};
   if (scalarFields.some(
-    (field) => redactedFields.includes(field.name)
+    (field) => redactedFields.includes(field.name) || DEFAULT_IGNORE_FIELDS_FOR_INPUT.includes(field.name) && !field.isUpdatedAt
   )) {
     return false;
   }
   scalarFields.forEach((field) => {
+    if (DEFAULT_IGNORE_FIELDS_FOR_INPUT.includes(field.name)) {
+      return;
+    }
     if (foreignKeys.includes(field.name)) {
       inputObj[field.name] = `scenario.${modelName}.two.${field.name}`;
     } else {
@@ -174,7 +186,7 @@ const fieldsToUpdate = async (model) => {
   const modelName = camelcase(singularize(model));
   let field, newValue, fieldName;
   const updatableFields = scalarFields.filter(
-    (scalar) => !redactedFields.includes(scalar.name)
+    (scalar) => !redactedFields.includes(scalar.name) && !DEFAULT_IGNORE_FIELDS_FOR_INPUT.includes(scalar.name)
   );
   field = updatableFields.find(
     (scalar) => !foreignKeys.includes(scalar.name)
@@ -273,13 +285,19 @@ const files = async ({
   }
   const prismaImportSource = "src/lib/db";
   let modelRelations;
+  let updateInputRequiredFields = [];
+  let nullableJsonFields = [];
+  let nullableRelations = [];
+  const schemaResult = await getSchema(model);
+  if (isServiceModel(schemaResult)) {
+    updateInputRequiredFields = requiredFieldsInUpdateInput(schemaResult);
+    nullableJsonFields = nullableJsonFieldsInInput(schemaResult);
+    nullableRelations = nullableRelationsForModel(schemaResult);
+  }
   if (relations) {
     modelRelations = relations;
-  } else {
-    const schemaResult = await getSchema(model);
-    if (isServiceModel(schemaResult)) {
-      modelRelations = relationsForModel(schemaResult);
-    }
+  } else if (isServiceModel(schemaResult)) {
+    modelRelations = relationsForModel(schemaResult);
   }
   const serviceFile = await templateForFile({
     name,
@@ -292,6 +310,9 @@ const files = async ({
       relations: modelRelations,
       idName,
       prismaImportSource,
+      updateInputRequiredFields,
+      nullableJsonFields,
+      nullableRelations,
       ...rest
     }
   });

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

@@ -1,6 +1,6 @@
 import type { QueryResolvers<% if (crud) { %>, MutationResolvers<% } %><% if (relations.length) { %>, ${singularPascalName}RelationResolvers<% } %> } from 'types/graphql'
 
-import { db } from 'src/lib/db'
+import { db<% if (crud && nullableJsonFields.length) { %>, Prisma<% } %> } from 'src/lib/db'
 <%
   // A compound `@@id([...])` key comes through as `{ fields, whereArg }`
   // instead of a single field name -- build the destructure/where-clause
@@ -13,8 +13,8 @@ import { db } from 'src/lib/db'
     ? `${idName.whereArg}: { ${idFields.join(', ')} }`
     : idName
   const idWhereFromRoot = idIsComposite
-    ? `${idName.whereArg}: { ${idFields.map((f) => `${f}: root?.${f}`).join(', ')} }`
-    : `${idName}: root?.${idName}`
+    ? `${idName.whereArg}: { ${idFields.map((f) => `${f}: root.${f}`).join(', ')} }`
+    : `${idName}: root.${idName}`
 %>
 export const ${pluralCamelName}: QueryResolvers['${pluralCamelName}'] = () => {
   return db.${singularCamelName}.findMany()
@@ -27,14 +27,27 @@ export const ${singularCamelName}: QueryResolvers['${singularCamelName}'] = ({ $
 }<% } %><% if (crud) { %>
 
 export const create${singularPascalName}: MutationResolvers['create${singularPascalName}'] = ({ input }) => {
-  return db.${singularCamelName}.create({
-    data: input,
+  return db.${singularCamelName}.create({<% if (nullableJsonFields.length) { %>
+    data: {
+      ...input,
+      // Prisma uses Prisma.DbNull, not null, to set a Json field to NULL<% nullableJsonFields.forEach((field) => { %>
+      ${field}: input.${field} === null ? Prisma.DbNull : input.${field},<% }) %>
+    },<% } else { %>
+    data: input,<% } %>
   })
 }
 
 export const update${singularPascalName}: MutationResolvers['update${singularPascalName}'] = ({ ${idArgs}, input }) => {
-  return db.${singularCamelName}.update({
-    data: input,
+  return db.${singularCamelName}.update({<% if (updateInputRequiredFields.length || nullableJsonFields.length) { %>
+    data: {
+      ...input,<% if (updateInputRequiredFields.length) { %>
+      // Every field in the GraphQL input is nullable, but Prisma doesn't
+      // accept null for required fields. undefined leaves the field unchanged<% updateInputRequiredFields.forEach((field) => { %>
+      ${field}: input.${field} ?? undefined,<% }) %><% } %><% if (nullableJsonFields.length) { %>
+      // Prisma uses Prisma.DbNull, not null, to set a Json field to NULL<% nullableJsonFields.forEach((field) => { %>
+      ${field}: input.${field} === null ? Prisma.DbNull : input.${field},<% }) %><% } %>
+    },<% } else { %>
+    data: input,<% } %>
     where: { ${idWhere} },
   })
 }
@@ -47,6 +60,6 @@ export const delete${singularPascalName}: MutationResolvers['delete${singularPas
 
 export const ${singularPascalName}: ${singularPascalName}RelationResolvers = {<% relations.forEach(relation => { %>
   ${relation}: (_obj, { root }) => {
-    return db.${singularCamelName}.findUnique({ where: { ${idWhereFromRoot} } }).${relation}()
+    return db.${singularCamelName}.findUnique<%= nullableRelations.includes(relation) ? '' : 'OrThrow' %>({ where: { ${idWhereFromRoot} } }).${relation}()
   },<% }) %>
 }<% } %>

package/dist/commands/generate/service/templates/test.ts.template

@@ -7,8 +7,10 @@
    // Looks for quoted strings, either by single (') or double (") quotes.
    // When found
    // - Removes the quotes around `scenario` variables.
-   // - Removes the quotes around `BigInt` fields.
-  const transformValue = (obj, type) => {
+   // - Removes the quotes around `BigInt` fields. GraphQL inputs type BigInt
+   //   values as numbers, so the `n` suffix is also removed when `asInput` is
+   //   set
+  const transformValue = (obj, type, asInput = false) => {
     if (type === 'DateTime') {
       return `new Date('${obj.toISOString()}')`
     } else if (type === 'Decimal') {
@@ -22,7 +24,7 @@
 
       // BigInt
       if (string.match(/^\"\d+n\"$/)) {
-        return string.slice(1, string.length - 1)
+        return string.slice(1, string.length - (asInput ? 2 : 1))
       }
 
       return string
@@ -57,7 +59,7 @@ describe('${pluralCamelName}', () => {
 
   <% if (create) { %>scenario('creates a ${singularCamelName}', async (${transformValue(create).includes('scenario.') ? 'scenario: StandardScenario' : ''}) => {
     const result = await create${singularPascalName}({
-      input: ${transformValue(create)},
+      input: ${transformValue(create, undefined, true)},
     })
 
     <% for (const [name, value] of Object.entries(create)) { %>
@@ -68,7 +70,7 @@ describe('${pluralCamelName}', () => {
     const original = await (${singularCamelName}({ ${idName}: scenario.${singularCamelName}.one.${idName} })) as ${prismaModel}
     const result = await update${singularPascalName}({
       ${idName}: original.${idName},
-      input: ${transformValue(update)},
+      input: ${transformValue(update, undefined, true)},
     })
 
     <% for (const [name, value] of Object.entries(update)) { %>

package/dist/commands/jobsHandler.js

@@ -7,9 +7,11 @@ const handler = async ({
   commands: _commands,
   ...options
 }) => {
-  const positionalArgs = Array.isArray(_) ? [..._] : [];
-  const commandArg = positionalArgs.pop();
-  const args = [commandArg == null ? "" : String(commandArg)];
+  const positionalArgs = (Array.isArray(_) ? _ : []).map(String);
+  if (positionalArgs[0] === "jobs") {
+    positionalArgs.shift();
+  }
+  const args = positionalArgs.length > 0 ? positionalArgs : [""];
   for (const [name, value] of Object.entries(options)) {
     args.push(name.length > 1 ? `--${name}` : `-${name}`);
     args.push(String(value));

package/dist/commands/setup/cache/templates/memcached.ts.template

@@ -10,21 +10,18 @@ const memJsFormattedLogger = {
   log: (msg: string) => logger.error(msg),
 }
 
-export let client: InMemoryClient | MemcachedClient
+// The client connects to Memcached the first time it's used. If it can't
+// connect, the error is logged and `cache()` runs the uncached function
+// instead
+export const client =
+  process.env.NODE_ENV === 'test'
+    ? new InMemoryClient()
+    : new MemcachedClient(process.env.CACHE_HOST, {
+        logger: memJsFormattedLogger,
+      })
 
-if (process.env.NODE_ENV === 'test') {
-  client = new InMemoryClient()
-} else {
-  try {
-    client = new MemcachedClient(process.env.CACHE_HOST, {
-      logger: memJsFormattedLogger,
-    })
-  } catch (e) {
-    logger.error(`Could not connect to cache: ${e.message}`)
-  }
-}
-
-export const { cache, cacheFindMany, cacheClient, deleteCacheKey } = createCache(client, {
-  logger,
-  timeout: 500,
-})
+export const { cache, cacheFindMany, cacheClient, deleteCacheKey } =
+  createCache(client, {
+    logger,
+    timeout: 500,
+  })

package/dist/commands/setup/cache/templates/redis.ts.template

@@ -1,24 +1,16 @@
-import {
-  createCache,
-  InMemoryClient,
-  RedisClient,
-} from '@cedarjs/api/cache'
+import { createCache, InMemoryClient, RedisClient } from '@cedarjs/api/cache'
 
 import { logger } from './logger'
 
-export let client: InMemoryClient | RedisClient
+// The client connects to Redis the first time it's used. If it can't connect,
+// the error is logged and `cache()` runs the uncached function instead
+export const client =
+  process.env.NODE_ENV === 'test'
+    ? new InMemoryClient()
+    : new RedisClient({ url: process.env.CACHE_HOST, logger })
 
-if (process.env.NODE_ENV === 'test') {
-  client = new InMemoryClient()
-} else {
-  try {
-    client = new RedisClient({ url: process.env.CACHE_HOST, logger })
-  } catch (e) {
-    logger.error(`Could not connect to cache: ${e.message}`)
-  }
-}
-
-export const { cache, cacheFindMany, cacheClient, deleteCacheKey } = createCache(client, {
-  logger,
-  timeout: 500,
-})
+export const { cache, cacheFindMany, cacheClient, deleteCacheKey } =
+  createCache(client, {
+    logger,
+    timeout: 500,
+  })

package/dist/commands/setup/deploy/helpers/index.js

@@ -131,7 +131,9 @@ function insertPluginsBeforeCedar({
   if (!configArg) {
     return null;
   }
-  const pluginsProp = configArg.properties.find(t.isObjectProperty);
+  const pluginsProp = configArg.properties.find(
+    (prop) => t.isObjectProperty(prop) && (!prop.computed && t.isIdentifier(prop.key, { name: "plugins" }) || t.isStringLiteral(prop.key, { value: "plugins" }))
+  );
   if (!t.isArrayExpression(pluginsProp?.value)) {
     return null;
   }

package/dist/commands/setup/deploy/providers/baremetal.js

@@ -1,8 +1,15 @@
+import { MONITORS } from "../../../deploy/baremetal/monitors.js";
 import { createHandler } from "../helpers/helpers.js";
 const command = "baremetal";
 const description = "Setup Baremetal deploy";
+const builder = (yargs) => yargs.option("monitor", {
+  description: "Process monitor to generate config for. Asks when not given. pm2 gets an ecosystem.config.js, systemd gets unit files in systemd/",
+  choices: MONITORS,
+  type: "string"
+});
 const handler = createHandler("baremetal");
 export {
+  builder,
   command,
   description,
   handler