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

package/dist/commands/setup/tenancy/authCodemod.js

@@ -0,0 +1,66 @@
+import j from "jscodeshift";
+function buildMembershipsSelectProperty() {
+  const snippet = `
+    const __tenancySnippet = {
+      memberships: {
+        select: {
+          id: true,
+          organizationId: true,
+          role: true,
+          organization: { select: { id: true, slug: true, name: true } },
+        },
+      },
+    }
+  `;
+  const property = j.withParser("ts")(snippet).find(j.ObjectProperty, { key: { name: "memberships" } }).nodes()[0];
+  if (!property) {
+    throw new Error("CEDAR_CODEMOD_ERR_AUTH_SHAPE_NOT_FOUND");
+  }
+  return property;
+}
+function transform(fileInfo) {
+  const root = j.withParser("tsx")(fileInfo.source);
+  let selectFound = false;
+  root.find(j.CallExpression, {
+    callee: {
+      type: "MemberExpression",
+      object: {
+        type: "MemberExpression",
+        object: { name: "db" },
+        property: { name: "user" }
+      },
+      property: { name: "findUnique" }
+    }
+  }).forEach((path) => {
+    const [args] = path.node.arguments;
+    if (!j.ObjectExpression.check(args)) {
+      return;
+    }
+    const selectProperty = args.properties.find(
+      (prop) => j.ObjectProperty.check(prop) && j.Identifier.check(prop.key) && prop.key.name === "select"
+    );
+    if (!selectProperty || !j.ObjectProperty.check(selectProperty) || !j.ObjectExpression.check(selectProperty.value)) {
+      return;
+    }
+    const alreadyHasMemberships = selectProperty.value.properties.some(
+      (prop) => j.ObjectProperty.check(prop) && j.Identifier.check(prop.key) && prop.key.name === "memberships"
+    );
+    if (!alreadyHasMemberships) {
+      selectProperty.value.properties.push(buildMembershipsSelectProperty());
+    }
+    selectFound = true;
+  });
+  if (!selectFound) {
+    throw new Error("CEDAR_CODEMOD_ERR_AUTH_SHAPE_NOT_FOUND");
+  }
+  const tenancyExportSnippet = `export { hasOrgRole, requireMembership } from '@cedarjs/tenancy'
+`;
+  const tenancyExport = j.withParser("ts")(tenancyExportSnippet).find(j.ExportNamedDeclaration).nodes()[0];
+  root.find(j.Program).forEach((path) => {
+    path.node.body.push(tenancyExport);
+  });
+  return root.toSource();
+}
+export {
+  transform as default
+};

package/dist/commands/setup/tenancy/dbCodemod.js

@@ -0,0 +1,64 @@
+import j from "jscodeshift";
+const DEFAULT_GLOBAL_MODELS = ["user", "organization", "membership"];
+function transform(fileInfo, _api, options) {
+  const root = j.withParser("tsx")(fileInfo.source);
+  const tenantField = typeof options.tenantField === "string" ? options.tenantField : void 0;
+  const imports = root.find(j.ImportDeclaration);
+  imports.at(-1).insertAfter(
+    j.importDeclaration(
+      [j.importSpecifier(j.identifier("createTenancyExtension"))],
+      j.literal("@cedarjs/tenancy")
+    )
+  );
+  const configProperties = [
+    ...tenantField ? [
+      j.objectProperty(
+        j.identifier("tenantField"),
+        j.stringLiteral(tenantField)
+      )
+    ] : [],
+    j.objectProperty(
+      j.identifier("models"),
+      j.objectExpression([
+        j.objectProperty(
+          j.identifier("allExcept"),
+          j.arrayExpression(
+            DEFAULT_GLOBAL_MODELS.map((name) => j.stringLiteral(name))
+          )
+        )
+      ])
+    )
+  ];
+  let found = false;
+  root.find(j.VariableDeclaration, { declarations: [{ id: { name: "db" } }] }).forEach((path) => {
+    const dbDeclaration = path.node.declarations[0];
+    if (!j.VariableDeclarator.check(dbDeclaration)) {
+      return;
+    }
+    if (j.NewExpression.check(dbDeclaration.init)) {
+      throw new Error("CEDAR_CODEMOD_ERR_OLD_FORMAT");
+    }
+    if (!j.Expression.check(dbDeclaration.init)) {
+      return;
+    }
+    found = true;
+    const extensionCall = j.callExpression(
+      j.identifier("createTenancyExtension"),
+      [j.objectExpression(configProperties)]
+    );
+    dbDeclaration.init = j.callExpression(
+      j.memberExpression(dbDeclaration.init, j.identifier("$extends")),
+      [extensionCall]
+    );
+  });
+  if (!found) {
+    throw new Error("CEDAR_CODEMOD_ERR_DB_SHAPE_NOT_FOUND");
+  }
+  return root.toSource().replace(
+    "createTenancyExtension(",
+    "createTenancyExtension<typeof prismaClient>("
+  );
+}
+export {
+  transform as default
+};

package/dist/commands/setup/tenancy/graphqlCodemod.js

@@ -0,0 +1,88 @@
+import j from "jscodeshift";
+function buildContextProperty() {
+  const snippet = `
+    const __tenancySnippet = {
+      context: async ({ context: gqlContext }) => {
+        const { currentUser, event, request, params } = gqlContext
+
+        // A user whose getCurrentUser result doesn't carry memberships
+        // can't be matched to an organization, so the request runs with
+        // no current organization set.
+        if (!isUserWithMemberships(currentUser)) {
+          return {}
+        }
+
+        // Yoga can populate either \`event\` (Lambda-style deployments) or
+        // \`request\` (Fetch-API-style deployments); resolveCurrentOrg reads
+        // the organization header off either.
+        const requestEvent = event ?? request
+
+        if (!requestEvent) {
+          return {}
+        }
+
+        const currentOrg = await resolveCurrentOrg({
+          event: requestEvent,
+          variables: params.variables,
+          currentUser,
+          lookupOrg: async (idOrSlug) =>
+            (await db.organization.findUnique({
+              where: { id: idOrSlug },
+              select: { id: true, slug: true },
+            })) ??
+            db.organization.findUnique({
+              where: { slug: idOrSlug },
+              select: { id: true, slug: true },
+            }),
+        })
+
+        return { currentOrg }
+      },
+    }
+  `;
+  const property = j.withParser("ts")(snippet).find(j.ObjectProperty, { key: { name: "context" } }).nodes()[0];
+  if (!property) {
+    throw new Error("CEDAR_CODEMOD_ERR_GRAPHQL_HANDLER_NOT_FOUND");
+  }
+  return property;
+}
+function addNamedImport(root, names, source) {
+  const imports = root.find(j.ImportDeclaration);
+  imports.at(-1).insertAfter(
+    j.importDeclaration(
+      names.map((name) => j.importSpecifier(j.identifier(name))),
+      j.literal(source)
+    )
+  );
+}
+function transform(fileInfo) {
+  const root = j.withParser("tsx")(fileInfo.source);
+  const handlerCalls = root.find(j.CallExpression, {
+    callee: { name: "createGraphQLHandler" }
+  });
+  if (handlerCalls.length === 0) {
+    throw new Error("CEDAR_CODEMOD_ERR_GRAPHQL_HANDLER_NOT_FOUND");
+  }
+  handlerCalls.forEach((path) => {
+    const [config] = path.node.arguments;
+    if (!j.ObjectExpression.check(config)) {
+      throw new Error("CEDAR_CODEMOD_ERR_GRAPHQL_HANDLER_NOT_FOUND");
+    }
+    const hasContext = config.properties.some(
+      (prop) => j.ObjectProperty.check(prop) && j.Identifier.check(prop.key) && prop.key.name === "context"
+    );
+    if (hasContext) {
+      throw new Error("CEDAR_CODEMOD_ERR_GRAPHQL_CONTEXT_EXISTS");
+    }
+    config.properties.push(buildContextProperty());
+  });
+  addNamedImport(
+    root,
+    ["isUserWithMemberships", "resolveCurrentOrg"],
+    "@cedarjs/tenancy"
+  );
+  return root.toSource();
+}
+export {
+  transform as default
+};

package/dist/commands/setup/tenancy/preflight.js

@@ -0,0 +1,49 @@
+import fs from "node:fs";
+import path from "node:path";
+import { formatCedarCommand } from "@cedarjs/cli-helpers/packageManager/display";
+const WEB_AUTH_EXTENSIONS = ["ts", "tsx", "js", "jsx"];
+function hasWebAuthFile(webSrcPath) {
+  return WEB_AUTH_EXTENSIONS.some(
+    (extension) => fs.existsSync(path.join(webSrcPath, `auth.${extension}`))
+  );
+}
+function authNotSetUpMessage() {
+  return [
+    "Auth is not set up in this project.",
+    "",
+    "Tenancy builds on your app's auth: it adds memberships to",
+    "`getCurrentUser`, and resolves the current organization from the",
+    "signed-in user's memberships. Set up auth first, then run this command",
+    "again:",
+    "",
+    `  ${formatCedarCommand(["setup", "auth", "dbAuth"])}`,
+    "",
+    "Any provider works. See https://cedarjs.com/docs/authentication"
+  ].join("\n");
+}
+function noUserModelMessage(schemaPath) {
+  return [
+    `No \`User\` model found in ${schemaPath}.`,
+    "",
+    "Tenancy hangs memberships off your app's `User` model, so it needs one",
+    "before it can add `Organization` and `Membership`.",
+    "",
+    "dbAuth adds this model for you. Providers that authenticate against an",
+    "external service leave it to you: give `User` its own id and store the",
+    "provider's id in a column beside it, so memberships keep working if you",
+    "switch providers or add a second one.",
+    "",
+    `Add a model like this one, run \`${formatCedarCommand(["prisma", "migrate", "dev"])}\`, then`,
+    "run this command again:",
+    "",
+    "  model User {",
+    "    id    String @id @default(cuid())",
+    "    email String @unique",
+    "  }"
+  ].join("\n");
+}
+export {
+  authNotSetUpMessage,
+  hasWebAuthFile,
+  noUserModelMessage
+};

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

@@ -0,0 +1,81 @@
+const ORGANIZATION_MODEL = `model Organization {
+  id          String       @id @default(cuid())
+  name        String
+  slug        String       @unique
+  createdAt   DateTime     @default(now())
+  updatedAt   DateTime     @updatedAt
+  memberships Membership[]
+}`;
+const MEMBERSHIP_MODEL = `model Membership {
+  id              String       @id @default(cuid())
+  role            String
+  // Null while the membership is a pending invitation.
+  userId          String?
+  organizationId  String
+  invitedById     String?
+  invitationToken String?      @unique
+  createdAt       DateTime     @default(now())
+  updatedAt   DateTime     @updatedAt
+  user            User?        @relation(fields: [userId], references: [id])
+  organization    Organization @relation(fields: [organizationId], references: [id])
+  invitedBy       Membership?  @relation("Inviter", fields: [invitedById], references: [id])
+  invitees        Membership[] @relation("Inviter")
+
+  @@unique([userId, organizationId])
+  @@index([organizationId])
+}`;
+const RW_DATA_MIGRATION_MODEL = `model RW_DataMigration {
+  version    String   @id
+  name       String
+  startedAt  DateTime
+  finishedAt DateTime
+}`;
+function hasModel(schema, modelName) {
+  return new RegExp(`\\bmodel\\s+${modelName}\\s*\\{`).test(schema);
+}
+function addTenancyModels(schema) {
+  return [ORGANIZATION_MODEL, MEMBERSHIP_MODEL].reduce(appendModel, schema);
+}
+function appendModel(schema, model) {
+  if (schema.includes(model)) {
+    return schema;
+  }
+  return `${schema.trimEnd()}
+
+${model}
+`;
+}
+function addDataMigrationModel(schema) {
+  if (hasModel(schema, "RW_DataMigration")) {
+    return schema;
+  }
+  return `${schema.trimEnd()}
+
+${RW_DATA_MIGRATION_MODEL}
+`;
+}
+function editSchema(schema, options) {
+  if (!hasModel(schema, "User")) {
+    throw new Error("CEDAR_TENANCY_ERR_NO_USER_MODEL");
+  }
+  const organizationIsCustomized = hasModel(schema, "Organization") && !schema.includes(ORGANIZATION_MODEL);
+  const membershipIsCustomized = hasModel(schema, "Membership") && !schema.includes(MEMBERSHIP_MODEL);
+  const modelsCustomized = organizationIsCustomized || membershipIsCustomized;
+  if (modelsCustomized && !options.force) {
+    return { schema: addDataMigrationModel(schema), outcome: "skipped" };
+  }
+  const withTenancyModels = addTenancyModels(schema);
+  return {
+    schema: addDataMigrationModel(withTenancyModels),
+    outcome: modelsCustomized ? "forced" : "added"
+  };
+}
+export {
+  MEMBERSHIP_MODEL,
+  ORGANIZATION_MODEL,
+  RW_DATA_MIGRATION_MODEL,
+  addDataMigrationModel,
+  addTenancyModels,
+  editSchema,
+  hasModel
+};

package/dist/commands/setup/tenancy/signupCodemod.js

@@ -0,0 +1,153 @@
+import j from "jscodeshift";
+function useShorthandUserAttributes(fn) {
+  const [firstParam] = fn.params;
+  if (!j.ObjectPattern.check(firstParam)) {
+    throw new Error("CEDAR_CODEMOD_ERR_SIGNUP_SHAPE_NOT_FOUND");
+  }
+  const userAttributesProperty = firstParam.properties.find(
+    (prop) => j.ObjectProperty.check(prop) && j.Identifier.check(prop.key) && prop.key.name === "userAttributes"
+  );
+  if (!userAttributesProperty || !j.ObjectProperty.check(userAttributesProperty)) {
+    throw new Error("CEDAR_CODEMOD_ERR_SIGNUP_SHAPE_NOT_FOUND");
+  }
+  userAttributesProperty.value = j.identifier("userAttributes");
+  userAttributesProperty.shorthand = true;
+}
+function addInvitationTokenToUserAttributes(root) {
+  root.find(j.TSInterfaceDeclaration, { id: { name: "UserAttributes" } }).forEach((path) => {
+    const alreadyHasField = path.node.body.body.some(
+      (member) => j.TSPropertySignature.check(member) && j.Identifier.check(member.key) && member.key.name === "invitationToken"
+    );
+    if (alreadyHasField) {
+      return;
+    }
+    path.node.body.body.push(
+      j.tsPropertySignature(
+        j.identifier("invitationToken"),
+        j.tsTypeAnnotation(j.tsStringKeyword()),
+        true
+        // optional
+      )
+    );
+  });
+}
+function wrapCreateCall(fn) {
+  fn.async = true;
+  const ensureCallStatement = j.expressionStatement(
+    j.awaitExpression(
+      j.callExpression(j.identifier("ensureDefaultOrganization"), [
+        j.objectExpression([
+          j.objectProperty(
+            j.identifier("currentUser"),
+            j.objectExpression([
+              j.objectProperty(
+                j.identifier("id"),
+                j.memberExpression(j.identifier("user"), j.identifier("id"))
+              ),
+              j.objectProperty(
+                j.identifier("memberships"),
+                j.arrayExpression([])
+              )
+            ])
+          ),
+          j.objectProperty(
+            j.identifier("invitationToken"),
+            j.memberExpression(
+              j.identifier("userAttributes"),
+              j.identifier("invitationToken")
+            )
+          )
+        ])
+      ])
+    )
+  );
+  const returnUserStatement = j.returnStatement(j.identifier("user"));
+  if (j.BlockStatement.check(fn.body)) {
+    const returnIndex = fn.body.body.findIndex(
+      (statement) => j.ReturnStatement.check(statement)
+    );
+    const returnStatement = fn.body.body[returnIndex];
+    if (returnIndex === -1 || !j.ReturnStatement.check(returnStatement) || !returnStatement.argument) {
+      throw new Error("CEDAR_CODEMOD_ERR_SIGNUP_SHAPE_NOT_FOUND");
+    }
+    const createUserStatement = j.variableDeclaration("const", [
+      j.variableDeclarator(
+        j.identifier("user"),
+        j.awaitExpression(returnStatement.argument)
+      )
+    ]);
+    fn.body.body.splice(
+      returnIndex,
+      1,
+      createUserStatement,
+      ensureCallStatement,
+      returnUserStatement
+    );
+    return;
+  }
+  if (j.Expression.check(fn.body)) {
+    const createUserStatement = j.variableDeclaration("const", [
+      j.variableDeclarator(
+        j.identifier("user"),
+        j.awaitExpression(
+          // ast-types' `Expression` checker type isn't assignable to
+          // `awaitExpression`'s narrower `ExpressionKind` union (a gap in
+          // ast-types' generated types); the `check()` call above already
+          // guarantees `fn.body` is a valid expression node.
+          fn.body
+        )
+      )
+    ]);
+    fn.body = j.blockStatement([
+      createUserStatement,
+      ensureCallStatement,
+      returnUserStatement
+    ]);
+    return;
+  }
+  throw new Error("CEDAR_CODEMOD_ERR_SIGNUP_SHAPE_NOT_FOUND");
+}
+function transform(fileInfo) {
+  const root = j.withParser("tsx")(fileInfo.source);
+  const signupOptionsDeclarators = root.find(j.VariableDeclarator, {
+    id: { name: "signupOptions" }
+  });
+  if (signupOptionsDeclarators.length === 0) {
+    throw new Error("CEDAR_CODEMOD_ERR_SIGNUP_SHAPE_NOT_FOUND");
+  }
+  let handlerFound = false;
+  signupOptionsDeclarators.forEach((path) => {
+    const init = path.node.init;
+    if (!j.ObjectExpression.check(init)) {
+      return;
+    }
+    const handlerProperty = init.properties.find(
+      (prop) => j.ObjectProperty.check(prop) && j.Identifier.check(prop.key) && prop.key.name === "handler"
+    );
+    if (!handlerProperty || !j.ObjectProperty.check(handlerProperty)) {
+      return;
+    }
+    const handlerFn = handlerProperty.value;
+    if (!j.ArrowFunctionExpression.check(handlerFn) && !j.FunctionExpression.check(handlerFn)) {
+      return;
+    }
+    useShorthandUserAttributes(handlerFn);
+    wrapCreateCall(handlerFn);
+    handlerFound = true;
+  });
+  if (!handlerFound) {
+    throw new Error("CEDAR_CODEMOD_ERR_SIGNUP_SHAPE_NOT_FOUND");
+  }
+  addInvitationTokenToUserAttributes(root);
+  const imports = root.find(j.ImportDeclaration);
+  imports.at(-1).insertAfter(
+    j.importDeclaration(
+      [j.importSpecifier(j.identifier("ensureDefaultOrganization"))],
+      j.literal("src/services/organizations/organizations")
+    )
+  );
+  return root.toSource();
+}
+export {
+  transform as default
+};

package/dist/commands/setup/tenancy/templates/InvitePage.tsx.template

@@ -0,0 +1,63 @@
+import { useEffect, useState } from 'react'
+
+import { navigate, routes, useParams } from '@cedarjs/router'
+import { Metadata, useMutation } from '@cedarjs/web'
+
+import { useAuth } from 'src/auth'
+
+const ACCEPT_INVITATION_MUTATION = gql`
+  mutation AcceptInvitationMutation($token: String!) {
+    acceptInvitation(token: $token) {
+      id
+      slug
+      name
+    }
+  }
+`
+
+/**
+ * Landing page for an invitation link (`/invite/{token}`). Outside
+ * `OrgScope`, since the visitor is not a member of the organization yet.
+ */
+const InvitePage = () => {
+  const { token } = useParams()
+  const { isAuthenticated, reauthenticate } = useAuth()
+  const [error, setError] = useState<string | null>(null)
+
+  const [acceptInvitation] = useMutation(ACCEPT_INVITATION_MUTATION, {
+    onCompleted: async (data) => {
+      await reauthenticate()
+      // TODO: point this at your app's organization home route, e.g.
+      // navigate(routes.orgHome({ orgSlug: data.acceptInvitation.slug }))
+      navigate(`/org/${data.acceptInvitation.slug}`)
+    },
+    onError: (mutationError) => setError(mutationError.message),
+  })
+
+  useEffect(() => {
+    if (isAuthenticated && token) {
+      acceptInvitation({ variables: { token } })
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [isAuthenticated, token])
+
+  if (!isAuthenticated) {
+    return (
+      <>
+        <Metadata title="Accept invitation" />
+        <p>Sign in or create an account to accept this invitation.</p>
+        <a href={`${routes.login()}?invitationToken=${token}`}>Log in</a>
+        <a href={`${routes.signup()}?invitationToken=${token}`}>Sign up</a>
+      </>
+    )
+  }
+
+  return (
+    <>
+      <Metadata title="Accept invitation" />
+      {error ? <p>{error}</p> : <p>Joining organization…</p>}
+    </>
+  )
+}
+
+export default InvitePage

package/dist/commands/setup/tenancy/templates/OrgScope.tsx.template

@@ -0,0 +1,40 @@
+import type { ReactNode } from 'react'
+
+import { OrgScope as TenancyOrgScope } from '@cedarjs/tenancy/web'
+
+import { useAuth } from 'src/auth'
+
+export interface OrgScopeProps {
+  /** Overrides the `orgSlug` route param. */
+  orgSlug?: string
+  children: ReactNode
+}
+
+/**
+ * Wraps organization routes with a per-organization Apollo client and a
+ * membership check, using this app's `useAuth`. Use with the router's
+ * `Set wrap`:
+ *
+ *   <Set wrap={OrgScope}>
+ *     <Route path="/org/{orgSlug}/projects" page={ProjectsPage} name="projects" />
+ *   </Set>
+ *
+ * Routes under `OrgScope` must not carry `prerender`: `OrgScope`'s nested
+ * Apollo client shadows the per-route client the prerenderer injects above
+ * `App`, so a prerendered query under here would not go through it.
+ */
+export const OrgScope = ({ orgSlug, children }: OrgScopeProps) => {
+  return (
+    <TenancyOrgScope
+      useAuth={useAuth}
+      orgSlug={orgSlug}
+      notAMember={
+        <div>
+          <p>You don&apos;t have access to this organization.</p>
+        </div>
+      }
+    >
+      {children}
+    </TenancyOrgScope>
+  )
+}

package/dist/commands/setup/tenancy/templates/ensureDefaultOrganizations.dataMigration.ts.template

@@ -0,0 +1,39 @@
+import type { PrismaClient } from 'src/lib/db'
+import { ensureDefaultOrganization } from 'src/services/organizations/organizations'
+
+const BATCH_SIZE = 100
+
+/**
+ * Existing users have no organization until this runs once: `setup tenancy`
+ * only wires new signups (via the GraphQL `context` function and, for dbAuth,
+ * the signup handler). Every user without a membership gets one, in batches,
+ * using the same `ensureDefaultOrganization` new signups use.
+ *
+ * Run with `__DATA_MIGRATE_UP_COMMAND__`, after
+ * `__PRISMA_MIGRATE_DEV_COMMAND__` has applied the
+ * `Organization`/`Membership` migration.
+ */
+export default async ({ db }: { db: PrismaClient }) => {
+  let cursor: string | undefined
+  let hasMore = true
+
+  while (hasMore) {
+    const users = await db.user.findMany({
+      take: BATCH_SIZE,
+      orderBy: { id: 'asc' },
+      ...(cursor ? { skip: 1, cursor: { id: cursor } } : {}),
+      include: { memberships: { select: { id: true } } },
+    })
+
+    for (const user of users) {
+      if (user.memberships.length === 0) {
+        await ensureDefaultOrganization({
+          currentUser: { id: user.id, memberships: [] },
+        })
+      }
+    }
+
+    cursor = users[users.length - 1]?.id
+    hasMore = users.length === BATCH_SIZE
+  }
+}