create-vexcms 0.0.19 → 0.1.0-alpha.2

package/templates/marketing-site/convex/_generated/server.js

@@ -0,0 +1,101 @@
+/* eslint-disable */
+/**
+ * Generated utilities for implementing server-side Convex query and mutation functions.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import {
+  actionGeneric,
+  httpActionGeneric,
+  queryGeneric,
+  mutationGeneric,
+  internalActionGeneric,
+  internalMutationGeneric,
+  internalQueryGeneric,
+} from "convex/server";
+
+/**
+ * Define a query in this Convex app's public API.
+ *
+ * This function will be allowed to read your Convex database and will be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export const query = queryGeneric;
+
+/**
+ * Define a query that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to read from your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export const internalQuery = internalQueryGeneric;
+
+/**
+ * Define a mutation in this Convex app's public API.
+ *
+ * This function will be allowed to modify your Convex database and will be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export const mutation = mutationGeneric;
+
+/**
+ * Define a mutation that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to modify your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export const internalMutation = internalMutationGeneric;
+
+/**
+ * Define an action in this Convex app's public API.
+ *
+ * An action is a function which can execute any JavaScript code, including non-deterministic
+ * code and code with side-effects, like calling third-party services.
+ * They can be run in Convex's JavaScript environment or in Node.js using the "use node" directive.
+ * They can interact with the database indirectly by calling queries and mutations using the {@link ActionCtx}.
+ *
+ * @param func - The action. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped action. Include this as an `export` to name it and make it accessible.
+ */
+export const action = actionGeneric;
+
+/**
+ * Define an action that is only accessible from other Convex functions (but not from the client).
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped function. Include this as an `export` to name it and make it accessible.
+ */
+export const internalAction = internalActionGeneric;
+
+/**
+ * Define an HTTP action.
+ *
+ * The wrapped function will be used to respond to HTTP requests received
+ * by a Convex deployment if the requests matches the path and method where
+ * this action is routed. Be sure to route your httpAction in `convex/http.js`.
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument
+ * and a Fetch API `Request` object as its second.
+ * @returns The wrapped function. Import this function from `convex/http.js` and route it to hook it up.
+ */
+export const httpAction = httpActionGeneric;
+
+/**
+ * Typesafe environment variables.
+ *
+ * This includes platform-provided env vars and any variables declared in
+ * `convex.config.ts`.
+ */
+export const env = process.env;

package/templates/marketing-site/convex/footers.ts

@@ -1,14 +1,18 @@
+import { TABLE_SLUG_FOOTERS } from "~/db/constants"
+import { find } from "~/vexcms/api"
+
 import { query } from "./_generated/server"
 
-/**
- * Get the first published footer.
- * Used by the public site layout for server-side preloading.
- */
+/** Same shape as `convex/headers.ts`'s `getFirst`, for `footers`. */
 export const getFirst = query({
   args: {},
   handler: async (ctx) => {
-    const footer = await ctx.db.query("footers").first()
-    if (!footer || footer.vex_status === "draft") return null
-    return footer
+    const [footer] = await find({
+      ctx,
+      collection: TABLE_SLUG_FOOTERS,
+      limit: 1,
+      access: { bypass: true },
+    })
+    return footer ?? null
   },
 })

package/templates/marketing-site/convex/headers.ts

@@ -1,14 +1,24 @@
+import { TABLE_SLUG_HEADERS } from "~/db/constants"
+import { find } from "~/vexcms/api"
+
 import { query } from "./_generated/server"
 
 /**
- * Get the first published header.
- * Used by the public site layout for server-side preloading.
+ * The site header — `headers` has one document in practice (seeded as "Main
+ * Header"); this returns the first one found, or `null`.
+ *
+ * Access is bypassed: the header renders on every public route before any
+ * session exists.
  */
 export const getFirst = query({
   args: {},
   handler: async (ctx) => {
-    const header = await ctx.db.query("headers").first()
-    if (!header || header.vex_status === "draft") return null
-    return header
+    const [header] = await find({
+      ctx,
+      collection: TABLE_SLUG_HEADERS,
+      limit: 1,
+      access: { bypass: true },
+    })
+    return header ?? null
   },
 })

package/templates/marketing-site/convex/pages.ts

@@ -1,46 +1,31 @@
-import { getPreviewSnapshot } from "@vexcms/core"
 import { v } from "convex/values"
 
 import { TABLE_SLUG_PAGES } from "~/db/constants"
+import { find } from "~/vexcms/api"
 
-import { vexQuery } from "./vex/helpers"
+import { query } from "./_generated/server"
 
 /**
- * Get a published page by slug.
- * Returns null if the page doesn't exist or isn't published.
+ * Returns the page document matching the given slug, or an empty array if
+ * none exists. Byte-identical in shape to `apps/test/convex/pages.ts:57-77`'s
+ * `getBySlug` (same collection-level `find` + `withIndex` + `access.bypass`
+ * pattern) with only the collection constant swapped.
  *
- * Uses vexQuery which automatically handles _vexDrafts arg
- * and provides ctx.drafts for draft-aware queries.
+ * Access is bypassed: rendered by `[slug]/page.tsx` and `page.tsx` for
+ * anonymous visitors, who have no roles and would otherwise be filtered out.
  */
-export const getBySlug = vexQuery({
+export const getBySlug = query({
   args: { slug: v.string() },
-  handler: async (ctx, args) => {
-    const page = await ctx.db
-      .query(TABLE_SLUG_PAGES)
-      .withIndex("by_slug", (q) => q.eq("slug", args.slug))
-      .first()
-
-    if (!page) {
-      return null
-    }
-
-    // On the public route, only return published pages
-    if (ctx.drafts === false && page.vex_status !== "published") {
-      return null
-    }
-
-    // For preview/snapshot mode, merge the draft snapshot
-    if (ctx.drafts === "snapshot") {
-      const snapshot = await getPreviewSnapshot({
-        collection: TABLE_SLUG_PAGES,
-        ctx,
-        documentId: page._id,
-      })
-      if (snapshot) {
-        return { ...page, ...snapshot }
-      }
-    }
-
-    return page
+  handler: async (ctx, { slug }) => {
+    return await find({
+      ctx,
+      collection: TABLE_SLUG_PAGES,
+      withIndex: {
+        name: "by_slug",
+        range: (q) => q.eq("slug", slug),
+      },
+      limit: 1,
+      access: { bypass: true },
+    })
   },
 })

package/templates/marketing-site/convex/schema.ts

@@ -0,0 +1,119 @@
+import { defineSchema, defineTable } from "convex/server"
+import { v } from "convex/values"
+
+import { TABLE_SLUG_ACCOUNTS, TABLE_SLUG_USERS } from "~/db/constants"
+
+import {
+  apikey,
+  images,
+  jwks,
+  session,
+  verification,
+  pages,
+  headers,
+  footers,
+  themes,
+} from "./vex.schema"
+
+export default defineSchema({
+  pages,
+  headers,
+  footers,
+  themes,
+  // `organization`/`team`/`teamMember`/`member`/`invitation`/`vex_globals` are
+  // hand-written, not imported from `./vex.schema` — the generator only emits
+  // them when the `organization()` plugin (`--orgs`) or a registered global is
+  // actually present in `vex.config.ts`. `access.ts` and every `getAuth`
+  // caller (`convex/vex.ts`, `convex/vex/media.ts`, `convex/vex/globals.ts`)
+  // reference `orgCollectionSlug`/`resolveOrgs: true` unconditionally, so
+  // these tables must exist in the schema from day one — enabling `--orgs`
+  // or registering a global later needs no schema migration.
+  vex_globals: defineTable({
+    slug: v.string(),
+    data: v.any(),
+  }).index("by_slug", ["slug"]),
+  images,
+  team: defineTable({
+    name: v.string(),
+    organizationId: v.string(),
+    createdAt: v.number(),
+    updatedAt: v.optional(v.number()),
+  }).index("by_organizationId", ["organizationId"]),
+  teamMember: defineTable({
+    teamId: v.string(),
+    userId: v.string(),
+    createdAt: v.optional(v.number()),
+  })
+    .index("by_teamId", ["teamId"])
+    .index("by_userId", ["userId"]),
+  organization: defineTable({
+    name: v.string(),
+    slug: v.string(),
+    logo: v.optional(v.string()),
+    createdAt: v.number(),
+    metadata: v.optional(v.string()),
+  }).index("by_slug", ["slug"]),
+  member: defineTable({
+    organizationId: v.string(),
+    userId: v.string(),
+    role: v.string(),
+    createdAt: v.number(),
+  })
+    .index("by_organizationId", ["organizationId"])
+    .index("by_userId", ["userId"]),
+  invitation: defineTable({
+    organizationId: v.string(),
+    email: v.string(),
+    role: v.optional(v.string()),
+    teamId: v.optional(v.string()),
+    status: v.string(),
+    expiresAt: v.number(),
+    createdAt: v.number(),
+    inviterId: v.string(),
+    roles: v.array(v.string()),
+  })
+    .index("by_organizationId", ["organizationId"])
+    .index("by_email", ["email"]),
+  session,
+  verification,
+  apikey,
+  jwks,
+
+  [TABLE_SLUG_USERS]: defineTable({
+    name: v.string(),
+    banExpires: v.optional(v.number()), // admin plugin
+    banned: v.optional(v.boolean()), // admin plugin
+    banReason: v.optional(v.string()), // admin plugin
+    createdAt: v.number(),
+    displayUsername: v.optional(v.union(v.null(), v.string())),
+    email: v.string(),
+    emailVerified: v.boolean(),
+    image: v.optional(v.string()),
+    isAnonymous: v.optional(v.union(v.null(), v.boolean())),
+    phoneNumber: v.optional(v.union(v.null(), v.string())),
+    phoneNumberVerified: v.optional(v.union(v.null(), v.boolean())),
+    role: v.optional(v.string()), // admin plugin — single string in BA 1.6
+    roles: v.array(v.string()), // our multi-role field via additionalFields
+    twoFactorEnabled: v.optional(v.union(v.null(), v.boolean())),
+    updatedAt: v.number(),
+    userId: v.optional(v.union(v.null(), v.string())),
+    username: v.optional(v.union(v.null(), v.string())),
+  }).index("by_email", ["email"]),
+
+  [TABLE_SLUG_ACCOUNTS]: defineTable({
+    accessToken: v.optional(v.string()),
+    accessTokenExpiresAt: v.optional(v.number()),
+    accountId: v.string(),
+    createdAt: v.number(),
+    idToken: v.optional(v.string()),
+    password: v.optional(v.string()),
+    providerId: v.string(),
+    refreshToken: v.optional(v.string()),
+    refreshTokenExpiresAt: v.optional(v.number()),
+    scope: v.optional(v.string()),
+    updatedAt: v.number(),
+    userId: v.string(),
+  })
+    .index("by_userId", ["userId"])
+    .index("by_accountId", ["accountId"]),
+})