@robelest/convex-auth 0.0.4-preview.2 → 0.0.4-preview.21

package/dist/component/public/enterprise/core.d.ts

@@ -0,0 +1,176 @@
+declare namespace core_d_exports {
+  export { enterpriseCreate, enterpriseDelete, enterpriseGet, enterpriseGetByDomain, enterpriseGetByGroup, enterpriseList, enterpriseUpdate };
+}
+/**
+ * Create a new enterprise record attached to a root group.
+ *
+ * Each group may only have one enterprise record. If an enterprise already
+ * exists for the given group, a `ENTERPRISE_ALREADY_EXISTS` error is thrown.
+ * The enterprise status defaults to `"draft"` when not explicitly provided.
+ *
+ * @param args.groupId - The ID of the root group that owns this enterprise.
+ * @param args.slug - An optional URL-friendly identifier for the enterprise.
+ * @param args.name - An optional human-readable display name for the enterprise.
+ * @param args.status - The lifecycle status (`"draft"`, `"active"`, or `"disabled"`). Defaults to `"draft"`.
+ * @param args.policy - An optional enterprise policy object controlling identity linking, provisioning, and deprovisioning behavior.
+ * @param args.config - An optional arbitrary configuration blob for enterprise-specific settings.
+ * @param args.extend - An optional arbitrary extension object for custom fields.
+ * @returns The ID of the newly created `Enterprise` document.
+ *
+ * @example
+ * ```ts
+ * const enterpriseId = await ctx.runMutation(
+ *   components.auth.enterprise.enterpriseCreate,
+ *   {
+ *     groupId: orgGroupId,
+ *     slug: "acme-corp",
+ *     name: "Acme Corporation",
+ *     status: "active",
+ *   },
+ * );
+ * ```
+ */
+declare const enterpriseCreate: any;
+/**
+ * Retrieve a single enterprise record by its document ID.
+ *
+ * Returns the full enterprise document if it exists, or `null` if no
+ * enterprise is found with the given ID.
+ *
+ * @param args.enterpriseId - The document ID of the enterprise to retrieve.
+ * @returns The enterprise document, or `null` if not found.
+ *
+ * @example
+ * ```ts
+ * const enterprise = await ctx.runQuery(
+ *   components.auth.enterprise.enterpriseGet,
+ *   { enterpriseId },
+ * );
+ * if (enterprise) {
+ *   console.log(enterprise.name, enterprise.status);
+ * }
+ * ```
+ */
+declare const enterpriseGet: any;
+/**
+ * Retrieve an enterprise record by the ID of its owning group.
+ *
+ * Looks up the enterprise that is linked to the specified group using the
+ * `group_id` index. Returns `null` if no enterprise is associated with the group.
+ *
+ * @param args.groupId - The ID of the root group whose enterprise record to look up.
+ * @returns The enterprise document, or `null` if the group has no enterprise.
+ *
+ * @example
+ * ```ts
+ * const enterprise = await ctx.runQuery(
+ *   components.auth.enterprise.enterpriseGetByGroup,
+ *   { groupId: orgGroupId },
+ * );
+ * ```
+ */
+declare const enterpriseGetByGroup: any;
+/**
+ * Retrieve an enterprise record by one of its linked domain names.
+ *
+ * Looks up an `EnterpriseDomain` row matching the given domain string, then
+ * resolves the parent enterprise. Returns both the enterprise and the matched
+ * domain document, or `null` if the domain is not registered or its enterprise
+ * no longer exists.
+ *
+ * @param args.domain - The domain name to search for (e.g. `"acme.com"`).
+ * @returns An object containing the `enterprise` and `domain` documents, or `null` if not found.
+ *
+ * @example
+ * ```ts
+ * const result = await ctx.runQuery(
+ *   components.auth.enterprise.enterpriseGetByDomain,
+ *   { domain: "acme.com" },
+ * );
+ * if (result) {
+ *   console.log(result.enterprise.name, result.domain.verifiedAt);
+ * }
+ * ```
+ */
+declare const enterpriseGetByDomain: any;
+/**
+ * List enterprise records with optional filtering and cursor-based pagination.
+ *
+ * Supports filtering by `groupId`, `slug`, and/or `status`. The query selects
+ * the most specific index available for the primary filter, then applies
+ * remaining predicates as post-filters. Results are ordered by creation time
+ * (or the specified field) and paginated using an opaque cursor.
+ *
+ * @param args.where - Optional filter criteria: `groupId`, `slug`, and/or `status`.
+ * @param args.limit - Maximum number of items per page (clamped between 1 and 100, defaults to 50).
+ * @param args.cursor - An opaque cursor string returned from a previous call to fetch the next page, or `null` / omitted for the first page.
+ * @param args.orderBy - The field to sort results by: `"_creationTime"`, `"name"`, `"slug"`, or `"status"`.
+ * @param args.order - Sort direction: `"asc"` or `"desc"` (defaults to `"desc"`).
+ * @returns A paginated result containing `items` (array of enterprise documents) and `nextCursor` (`string | null`).
+ *
+ * @example
+ * ```ts
+ * const page = await ctx.runQuery(
+ *   components.auth.enterprise.enterpriseList,
+ *   {
+ *     where: { status: "active" },
+ *     limit: 25,
+ *     order: "asc",
+ *   },
+ * );
+ * for (const ent of page.items) {
+ *   console.log(ent.name);
+ * }
+ * // Fetch next page:
+ * const nextPage = await ctx.runQuery(
+ *   components.auth.enterprise.enterpriseList,
+ *   { where: { status: "active" }, cursor: page.nextCursor },
+ * );
+ * ```
+ */
+declare const enterpriseList: any;
+/**
+ * Partially update (patch) an existing enterprise record.
+ *
+ * Merges the provided `data` fields into the existing enterprise document.
+ * Only the fields present in `data` are changed; all other fields are preserved.
+ *
+ * @param args.enterpriseId - The document ID of the enterprise to update.
+ * @param args.data - An object containing the fields to update (e.g. `{ name, status, policy }`).
+ * @returns `null` on success.
+ *
+ * @example
+ * ```ts
+ * await ctx.runMutation(
+ *   components.auth.enterprise.enterpriseUpdate,
+ *   {
+ *     enterpriseId,
+ *     data: { status: "active", name: "Acme Corp (Renamed)" },
+ *   },
+ * );
+ * ```
+ */
+declare const enterpriseUpdate: any;
+/**
+ * Delete an enterprise record and all of its associated child data.
+ *
+ * This cascading delete removes the enterprise document along with all linked
+ * domain records, domain verification records, and enterprise secrets. Callers
+ * should ensure that higher-level cleanup (e.g. SCIM identities, webhook
+ * endpoints) is handled separately if needed.
+ *
+ * @param args.enterpriseId - The document ID of the enterprise to delete.
+ * @returns `null` on success.
+ *
+ * @example
+ * ```ts
+ * await ctx.runMutation(
+ *   components.auth.enterprise.enterpriseDelete,
+ *   { enterpriseId },
+ * );
+ * ```
+ */
+declare const enterpriseDelete: any;
+//#endregion
+export { core_d_exports, enterpriseCreate, enterpriseDelete, enterpriseGet, enterpriseGetByDomain, enterpriseGetByGroup, enterpriseList, enterpriseUpdate };
+//# sourceMappingURL=core.d.ts.map

package/dist/component/public/enterprise/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","names":[],"sources":["../../../../src/component/public/enterprise/core.ts"],"mappings":";;;;;;;;;;;;;;;AAuCA;;;;;AAiDA;;;;;AAyBA;;;;;AAiCA;;cA3Ga,gBAAA;;;AAuKb;;;;;AA2FA;;;;;AA4BA;;;;;;;;cA7Oa,aAAA;;;;;;;;;;;;;;;;;;cAyBA,oBAAA;;;;;;;;;;;;;;;;;;;;;;;cAiCA,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4DA,cAAA;;;;;;;;;;;;;;;;;;;;;;cA2FA,gBAAA;;;;;;;;;;;;;;;;;;;;cA4BA,gBAAA"}

package/dist/component/public/enterprise/core.js

@@ -0,0 +1,292 @@
+import { mutation, query } from "../../functions.js";
+import { vEnterpriseDoc, vEnterpriseDomainDoc, vEnterprisePolicy, vEnterpriseStatus, vPaginated } from "../../model.js";
+import { ConvexError, v } from "convex/values";
+
+//#region src/component/public/enterprise/core.ts
+/**
+* Create a new enterprise record attached to a root group.
+*
+* Each group may only have one enterprise record. If an enterprise already
+* exists for the given group, a `ENTERPRISE_ALREADY_EXISTS` error is thrown.
+* The enterprise status defaults to `"draft"` when not explicitly provided.
+*
+* @param args.groupId - The ID of the root group that owns this enterprise.
+* @param args.slug - An optional URL-friendly identifier for the enterprise.
+* @param args.name - An optional human-readable display name for the enterprise.
+* @param args.status - The lifecycle status (`"draft"`, `"active"`, or `"disabled"`). Defaults to `"draft"`.
+* @param args.policy - An optional enterprise policy object controlling identity linking, provisioning, and deprovisioning behavior.
+* @param args.config - An optional arbitrary configuration blob for enterprise-specific settings.
+* @param args.extend - An optional arbitrary extension object for custom fields.
+* @returns The ID of the newly created `Enterprise` document.
+*
+* @example
+* ```ts
+* const enterpriseId = await ctx.runMutation(
+*   components.auth.enterprise.enterpriseCreate,
+*   {
+*     groupId: orgGroupId,
+*     slug: "acme-corp",
+*     name: "Acme Corporation",
+*     status: "active",
+*   },
+* );
+* ```
+*/
+const enterpriseCreate = mutation({
+	args: {
+		groupId: v.id("Group"),
+		slug: v.optional(v.string()),
+		name: v.optional(v.string()),
+		status: v.optional(vEnterpriseStatus),
+		policy: v.optional(vEnterprisePolicy),
+		config: v.optional(v.any()),
+		extend: v.optional(v.any())
+	},
+	returns: v.id("Enterprise"),
+	handler: async (ctx, args) => {
+		if (await ctx.db.query("Enterprise").withIndex("group_id", (idx) => idx.eq("groupId", args.groupId)).first()) throw new ConvexError({
+			code: "ENTERPRISE_ALREADY_EXISTS",
+			message: "An enterprise record already exists for this group."
+		});
+		return await ctx.db.insert("Enterprise", {
+			...args,
+			status: args.status ?? "draft"
+		});
+	}
+});
+/**
+* Retrieve a single enterprise record by its document ID.
+*
+* Returns the full enterprise document if it exists, or `null` if no
+* enterprise is found with the given ID.
+*
+* @param args.enterpriseId - The document ID of the enterprise to retrieve.
+* @returns The enterprise document, or `null` if not found.
+*
+* @example
+* ```ts
+* const enterprise = await ctx.runQuery(
+*   components.auth.enterprise.enterpriseGet,
+*   { enterpriseId },
+* );
+* if (enterprise) {
+*   console.log(enterprise.name, enterprise.status);
+* }
+* ```
+*/
+const enterpriseGet = query({
+	args: { enterpriseId: v.id("Enterprise") },
+	returns: v.union(vEnterpriseDoc, v.null()),
+	handler: async (ctx, { enterpriseId }) => {
+		return await ctx.db.get("Enterprise", enterpriseId);
+	}
+});
+/**
+* Retrieve an enterprise record by the ID of its owning group.
+*
+* Looks up the enterprise that is linked to the specified group using the
+* `group_id` index. Returns `null` if no enterprise is associated with the group.
+*
+* @param args.groupId - The ID of the root group whose enterprise record to look up.
+* @returns The enterprise document, or `null` if the group has no enterprise.
+*
+* @example
+* ```ts
+* const enterprise = await ctx.runQuery(
+*   components.auth.enterprise.enterpriseGetByGroup,
+*   { groupId: orgGroupId },
+* );
+* ```
+*/
+const enterpriseGetByGroup = query({
+	args: { groupId: v.id("Group") },
+	returns: v.union(vEnterpriseDoc, v.null()),
+	handler: async (ctx, { groupId }) => {
+		return await ctx.db.query("Enterprise").withIndex("group_id", (idx) => idx.eq("groupId", groupId)).first();
+	}
+});
+/**
+* Retrieve an enterprise record by one of its linked domain names.
+*
+* Looks up an `EnterpriseDomain` row matching the given domain string, then
+* resolves the parent enterprise. Returns both the enterprise and the matched
+* domain document, or `null` if the domain is not registered or its enterprise
+* no longer exists.
+*
+* @param args.domain - The domain name to search for (e.g. `"acme.com"`).
+* @returns An object containing the `enterprise` and `domain` documents, or `null` if not found.
+*
+* @example
+* ```ts
+* const result = await ctx.runQuery(
+*   components.auth.enterprise.enterpriseGetByDomain,
+*   { domain: "acme.com" },
+* );
+* if (result) {
+*   console.log(result.enterprise.name, result.domain.verifiedAt);
+* }
+* ```
+*/
+const enterpriseGetByDomain = query({
+	args: { domain: v.string() },
+	returns: v.union(v.object({
+		enterprise: vEnterpriseDoc,
+		domain: vEnterpriseDomainDoc
+	}), v.null()),
+	handler: async (ctx, { domain }) => {
+		const domainRow = await ctx.db.query("EnterpriseDomain").withIndex("domain", (idx) => idx.eq("domain", domain)).first();
+		if (!domainRow) return null;
+		const enterprise = await ctx.db.get("Enterprise", domainRow.enterpriseId);
+		if (!enterprise) return null;
+		return {
+			enterprise,
+			domain: domainRow
+		};
+	}
+});
+/**
+* List enterprise records with optional filtering and cursor-based pagination.
+*
+* Supports filtering by `groupId`, `slug`, and/or `status`. The query selects
+* the most specific index available for the primary filter, then applies
+* remaining predicates as post-filters. Results are ordered by creation time
+* (or the specified field) and paginated using an opaque cursor.
+*
+* @param args.where - Optional filter criteria: `groupId`, `slug`, and/or `status`.
+* @param args.limit - Maximum number of items per page (clamped between 1 and 100, defaults to 50).
+* @param args.cursor - An opaque cursor string returned from a previous call to fetch the next page, or `null` / omitted for the first page.
+* @param args.orderBy - The field to sort results by: `"_creationTime"`, `"name"`, `"slug"`, or `"status"`.
+* @param args.order - Sort direction: `"asc"` or `"desc"` (defaults to `"desc"`).
+* @returns A paginated result containing `items` (array of enterprise documents) and `nextCursor` (`string | null`).
+*
+* @example
+* ```ts
+* const page = await ctx.runQuery(
+*   components.auth.enterprise.enterpriseList,
+*   {
+*     where: { status: "active" },
+*     limit: 25,
+*     order: "asc",
+*   },
+* );
+* for (const ent of page.items) {
+*   console.log(ent.name);
+* }
+* // Fetch next page:
+* const nextPage = await ctx.runQuery(
+*   components.auth.enterprise.enterpriseList,
+*   { where: { status: "active" }, cursor: page.nextCursor },
+* );
+* ```
+*/
+const enterpriseList = query({
+	args: {
+		where: v.optional(v.object({
+			groupId: v.optional(v.id("Group")),
+			slug: v.optional(v.string()),
+			status: v.optional(vEnterpriseStatus)
+		})),
+		limit: v.optional(v.number()),
+		cursor: v.optional(v.union(v.string(), v.null())),
+		orderBy: v.optional(v.union(v.literal("_creationTime"), v.literal("name"), v.literal("slug"), v.literal("status"))),
+		order: v.optional(v.union(v.literal("asc"), v.literal("desc")))
+	},
+	returns: vPaginated(vEnterpriseDoc),
+	handler: async (ctx, args) => {
+		const where = args.where ?? {};
+		const limit = Math.min(Math.max(args.limit ?? 50, 1), 100);
+		const order = args.order ?? "desc";
+		let q;
+		if (where.groupId !== void 0) q = ctx.db.query("Enterprise").withIndex("group_id", (idx) => idx.eq("groupId", where.groupId));
+		else if (where.slug !== void 0) q = ctx.db.query("Enterprise").withIndex("slug", (idx) => idx.eq("slug", where.slug));
+		else if (where.status !== void 0) q = ctx.db.query("Enterprise").withIndex("status", (idx) => idx.eq("status", where.status));
+		else q = ctx.db.query("Enterprise");
+		if (where.groupId !== void 0 && where.slug !== void 0) q = q.filter((f) => f.eq(f.field("slug"), where.slug));
+		if (where.status !== void 0 && where.groupId === void 0) {} else if (where.status !== void 0) q = q.filter((f) => f.eq(f.field("status"), where.status));
+		q = q.order(order);
+		const all = await q.collect();
+		let startIdx = 0;
+		if (args.cursor) {
+			const cursorIdx = all.findIndex((doc) => doc._id === args.cursor);
+			if (cursorIdx !== -1) startIdx = cursorIdx + 1;
+		}
+		const page = all.slice(startIdx, startIdx + limit + 1);
+		const hasMore = page.length > limit;
+		const items = hasMore ? page.slice(0, limit) : page;
+		return {
+			items,
+			nextCursor: hasMore ? items[items.length - 1]._id : null
+		};
+	}
+});
+/**
+* Partially update (patch) an existing enterprise record.
+*
+* Merges the provided `data` fields into the existing enterprise document.
+* Only the fields present in `data` are changed; all other fields are preserved.
+*
+* @param args.enterpriseId - The document ID of the enterprise to update.
+* @param args.data - An object containing the fields to update (e.g. `{ name, status, policy }`).
+* @returns `null` on success.
+*
+* @example
+* ```ts
+* await ctx.runMutation(
+*   components.auth.enterprise.enterpriseUpdate,
+*   {
+*     enterpriseId,
+*     data: { status: "active", name: "Acme Corp (Renamed)" },
+*   },
+* );
+* ```
+*/
+const enterpriseUpdate = mutation({
+	args: {
+		enterpriseId: v.id("Enterprise"),
+		data: v.any()
+	},
+	returns: v.null(),
+	handler: async (ctx, { enterpriseId, data }) => {
+		await ctx.db.patch(enterpriseId, data);
+		return null;
+	}
+});
+/**
+* Delete an enterprise record and all of its associated child data.
+*
+* This cascading delete removes the enterprise document along with all linked
+* domain records, domain verification records, and enterprise secrets. Callers
+* should ensure that higher-level cleanup (e.g. SCIM identities, webhook
+* endpoints) is handled separately if needed.
+*
+* @param args.enterpriseId - The document ID of the enterprise to delete.
+* @returns `null` on success.
+*
+* @example
+* ```ts
+* await ctx.runMutation(
+*   components.auth.enterprise.enterpriseDelete,
+*   { enterpriseId },
+* );
+* ```
+*/
+const enterpriseDelete = mutation({
+	args: { enterpriseId: v.id("Enterprise") },
+	returns: v.null(),
+	handler: async (ctx, { enterpriseId }) => {
+		const domains = await ctx.db.query("EnterpriseDomain").withIndex("enterprise_id", (idx) => idx.eq("enterpriseId", enterpriseId)).collect();
+		for (const domain of domains) {
+			const verification = await ctx.db.query("EnterpriseDomainVerification").withIndex("domain_id", (idx) => idx.eq("domainId", domain._id)).first();
+			if (verification) await ctx.db.delete(verification._id);
+			await ctx.db.delete(domain._id);
+		}
+		const secrets = await ctx.db.query("EnterpriseSecret").withIndex("enterprise_id", (idx) => idx.eq("enterpriseId", enterpriseId)).collect();
+		for (const secret of secrets) await ctx.db.delete(secret._id);
+		await ctx.db.delete(enterpriseId);
+		return null;
+	}
+});
+
+//#endregion
+export { enterpriseCreate, enterpriseDelete, enterpriseGet, enterpriseGetByDomain, enterpriseGetByGroup, enterpriseList, enterpriseUpdate };
+//# sourceMappingURL=core.js.map

package/dist/component/public/enterprise/core.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.js","names":[],"sources":["../../../../src/component/public/enterprise/core.ts"],"sourcesContent":["import { ConvexError, v } from \"convex/values\";\nimport { mutation, query } from \"../../functions\";\nimport {\n  vEnterpriseDoc,\n  vEnterpriseDomainDoc,\n  vEnterprisePolicy,\n  vEnterpriseStatus,\n  vPaginated,\n} from \"../../model\";\n\n/**\n * Create a new enterprise record attached to a root group.\n *\n * Each group may only have one enterprise record. If an enterprise already\n * exists for the given group, a `ENTERPRISE_ALREADY_EXISTS` error is thrown.\n * The enterprise status defaults to `\"draft\"` when not explicitly provided.\n *\n * @param args.groupId - The ID of the root group that owns this enterprise.\n * @param args.slug - An optional URL-friendly identifier for the enterprise.\n * @param args.name - An optional human-readable display name for the enterprise.\n * @param args.status - The lifecycle status (`\"draft\"`, `\"active\"`, or `\"disabled\"`). Defaults to `\"draft\"`.\n * @param args.policy - An optional enterprise policy object controlling identity linking, provisioning, and deprovisioning behavior.\n * @param args.config - An optional arbitrary configuration blob for enterprise-specific settings.\n * @param args.extend - An optional arbitrary extension object for custom fields.\n * @returns The ID of the newly created `Enterprise` document.\n *\n * @example\n * ```ts\n * const enterpriseId = await ctx.runMutation(\n *   components.auth.enterprise.enterpriseCreate,\n *   {\n *     groupId: orgGroupId,\n *     slug: \"acme-corp\",\n *     name: \"Acme Corporation\",\n *     status: \"active\",\n *   },\n * );\n * ```\n */\nexport const enterpriseCreate = mutation({\n  args: {\n    groupId: v.id(\"Group\"),\n    slug: v.optional(v.string()),\n    name: v.optional(v.string()),\n    status: v.optional(vEnterpriseStatus),\n    policy: v.optional(vEnterprisePolicy),\n    config: v.optional(v.any()),\n    extend: v.optional(v.any()),\n  },\n  returns: v.id(\"Enterprise\"),\n  handler: async (ctx, args) => {\n    const existing = await ctx.db\n      .query(\"Enterprise\")\n      .withIndex(\"group_id\", (idx) => idx.eq(\"groupId\", args.groupId))\n      .first();\n    if (existing) {\n      throw new ConvexError({\n        code: \"ENTERPRISE_ALREADY_EXISTS\",\n        message: \"An enterprise record already exists for this group.\",\n      });\n    }\n    return await ctx.db.insert(\"Enterprise\", {\n      ...args,\n      status: args.status ?? \"draft\",\n    });\n  },\n});\n\n/**\n * Retrieve a single enterprise record by its document ID.\n *\n * Returns the full enterprise document if it exists, or `null` if no\n * enterprise is found with the given ID.\n *\n * @param args.enterpriseId - The document ID of the enterprise to retrieve.\n * @returns The enterprise document, or `null` if not found.\n *\n * @example\n * ```ts\n * const enterprise = await ctx.runQuery(\n *   components.auth.enterprise.enterpriseGet,\n *   { enterpriseId },\n * );\n * if (enterprise) {\n *   console.log(enterprise.name, enterprise.status);\n * }\n * ```\n */\nexport const enterpriseGet = query({\n  args: { enterpriseId: v.id(\"Enterprise\") },\n  returns: v.union(vEnterpriseDoc, v.null()),\n  handler: async (ctx, { enterpriseId }) => {\n    return await ctx.db.get(\"Enterprise\", enterpriseId);\n  },\n});\n\n/**\n * Retrieve an enterprise record by the ID of its owning group.\n *\n * Looks up the enterprise that is linked to the specified group using the\n * `group_id` index. Returns `null` if no enterprise is associated with the group.\n *\n * @param args.groupId - The ID of the root group whose enterprise record to look up.\n * @returns The enterprise document, or `null` if the group has no enterprise.\n *\n * @example\n * ```ts\n * const enterprise = await ctx.runQuery(\n *   components.auth.enterprise.enterpriseGetByGroup,\n *   { groupId: orgGroupId },\n * );\n * ```\n */\nexport const enterpriseGetByGroup = query({\n  args: { groupId: v.id(\"Group\") },\n  returns: v.union(vEnterpriseDoc, v.null()),\n  handler: async (ctx, { groupId }) => {\n    return await ctx.db\n      .query(\"Enterprise\")\n      .withIndex(\"group_id\", (idx) => idx.eq(\"groupId\", groupId))\n      .first();\n  },\n});\n\n/**\n * Retrieve an enterprise record by one of its linked domain names.\n *\n * Looks up an `EnterpriseDomain` row matching the given domain string, then\n * resolves the parent enterprise. Returns both the enterprise and the matched\n * domain document, or `null` if the domain is not registered or its enterprise\n * no longer exists.\n *\n * @param args.domain - The domain name to search for (e.g. `\"acme.com\"`).\n * @returns An object containing the `enterprise` and `domain` documents, or `null` if not found.\n *\n * @example\n * ```ts\n * const result = await ctx.runQuery(\n *   components.auth.enterprise.enterpriseGetByDomain,\n *   { domain: \"acme.com\" },\n * );\n * if (result) {\n *   console.log(result.enterprise.name, result.domain.verifiedAt);\n * }\n * ```\n */\nexport const enterpriseGetByDomain = query({\n  args: { domain: v.string() },\n  returns: v.union(\n    v.object({\n      enterprise: vEnterpriseDoc,\n      domain: vEnterpriseDomainDoc,\n    }),\n    v.null(),\n  ),\n  handler: async (ctx, { domain }) => {\n    const domainRow = await ctx.db\n      .query(\"EnterpriseDomain\")\n      .withIndex(\"domain\", (idx) => idx.eq(\"domain\", domain))\n      .first();\n    if (!domainRow) {\n      return null;\n    }\n    const enterprise = await ctx.db.get(\"Enterprise\", domainRow.enterpriseId);\n    if (!enterprise) {\n      return null;\n    }\n    return { enterprise, domain: domainRow };\n  },\n});\n\n/**\n * List enterprise records with optional filtering and cursor-based pagination.\n *\n * Supports filtering by `groupId`, `slug`, and/or `status`. The query selects\n * the most specific index available for the primary filter, then applies\n * remaining predicates as post-filters. Results are ordered by creation time\n * (or the specified field) and paginated using an opaque cursor.\n *\n * @param args.where - Optional filter criteria: `groupId`, `slug`, and/or `status`.\n * @param args.limit - Maximum number of items per page (clamped between 1 and 100, defaults to 50).\n * @param args.cursor - An opaque cursor string returned from a previous call to fetch the next page, or `null` / omitted for the first page.\n * @param args.orderBy - The field to sort results by: `\"_creationTime\"`, `\"name\"`, `\"slug\"`, or `\"status\"`.\n * @param args.order - Sort direction: `\"asc\"` or `\"desc\"` (defaults to `\"desc\"`).\n * @returns A paginated result containing `items` (array of enterprise documents) and `nextCursor` (`string | null`).\n *\n * @example\n * ```ts\n * const page = await ctx.runQuery(\n *   components.auth.enterprise.enterpriseList,\n *   {\n *     where: { status: \"active\" },\n *     limit: 25,\n *     order: \"asc\",\n *   },\n * );\n * for (const ent of page.items) {\n *   console.log(ent.name);\n * }\n * // Fetch next page:\n * const nextPage = await ctx.runQuery(\n *   components.auth.enterprise.enterpriseList,\n *   { where: { status: \"active\" }, cursor: page.nextCursor },\n * );\n * ```\n */\nexport const enterpriseList = query({\n  args: {\n    where: v.optional(\n      v.object({\n        groupId: v.optional(v.id(\"Group\")),\n        slug: v.optional(v.string()),\n        status: v.optional(vEnterpriseStatus),\n      }),\n    ),\n    limit: v.optional(v.number()),\n    cursor: v.optional(v.union(v.string(), v.null())),\n    orderBy: v.optional(\n      v.union(\n        v.literal(\"_creationTime\"),\n        v.literal(\"name\"),\n        v.literal(\"slug\"),\n        v.literal(\"status\"),\n      ),\n    ),\n    order: v.optional(v.union(v.literal(\"asc\"), v.literal(\"desc\"))),\n  },\n  returns: vPaginated(vEnterpriseDoc),\n  handler: async (ctx, args) => {\n    const where = args.where ?? {};\n    const limit = Math.min(Math.max(args.limit ?? 50, 1), 100);\n    const order = args.order ?? \"desc\";\n\n    let q;\n    if (where.groupId !== undefined) {\n      q = ctx.db\n        .query(\"Enterprise\")\n        .withIndex(\"group_id\", (idx) => idx.eq(\"groupId\", where.groupId!));\n    } else if (where.slug !== undefined) {\n      q = ctx.db\n        .query(\"Enterprise\")\n        .withIndex(\"slug\", (idx) => idx.eq(\"slug\", where.slug!));\n    } else if (where.status !== undefined) {\n      q = ctx.db\n        .query(\"Enterprise\")\n        .withIndex(\"status\", (idx) => idx.eq(\"status\", where.status!));\n    } else {\n      q = ctx.db.query(\"Enterprise\");\n    }\n\n    if (where.groupId !== undefined && where.slug !== undefined) {\n      q = q.filter((f) => f.eq(f.field(\"slug\"), where.slug!));\n    }\n    if (where.status !== undefined && where.groupId === undefined) {\n      // already handled by index in the dedicated branch\n    } else if (where.status !== undefined) {\n      q = q.filter((f) => f.eq(f.field(\"status\"), where.status!));\n    }\n\n    q = q.order(order);\n    const all = await q.collect();\n    let startIdx = 0;\n    if (args.cursor) {\n      const cursorIdx = all.findIndex((doc) => doc._id === args.cursor);\n      if (cursorIdx !== -1) {\n        startIdx = cursorIdx + 1;\n      }\n    }\n    const page = all.slice(startIdx, startIdx + limit + 1);\n    const hasMore = page.length > limit;\n    const items = hasMore ? page.slice(0, limit) : page;\n    const nextCursor = hasMore ? items[items.length - 1]._id : null;\n    return { items, nextCursor };\n  },\n});\n\n/**\n * Partially update (patch) an existing enterprise record.\n *\n * Merges the provided `data` fields into the existing enterprise document.\n * Only the fields present in `data` are changed; all other fields are preserved.\n *\n * @param args.enterpriseId - The document ID of the enterprise to update.\n * @param args.data - An object containing the fields to update (e.g. `{ name, status, policy }`).\n * @returns `null` on success.\n *\n * @example\n * ```ts\n * await ctx.runMutation(\n *   components.auth.enterprise.enterpriseUpdate,\n *   {\n *     enterpriseId,\n *     data: { status: \"active\", name: \"Acme Corp (Renamed)\" },\n *   },\n * );\n * ```\n */\nexport const enterpriseUpdate = mutation({\n  args: { enterpriseId: v.id(\"Enterprise\"), data: v.any() },\n  returns: v.null(),\n  handler: async (ctx, { enterpriseId, data }) => {\n    await ctx.db.patch(enterpriseId, data);\n    return null;\n  },\n});\n\n/**\n * Delete an enterprise record and all of its associated child data.\n *\n * This cascading delete removes the enterprise document along with all linked\n * domain records, domain verification records, and enterprise secrets. Callers\n * should ensure that higher-level cleanup (e.g. SCIM identities, webhook\n * endpoints) is handled separately if needed.\n *\n * @param args.enterpriseId - The document ID of the enterprise to delete.\n * @returns `null` on success.\n *\n * @example\n * ```ts\n * await ctx.runMutation(\n *   components.auth.enterprise.enterpriseDelete,\n *   { enterpriseId },\n * );\n * ```\n */\nexport const enterpriseDelete = mutation({\n  args: { enterpriseId: v.id(\"Enterprise\") },\n  returns: v.null(),\n  handler: async (ctx, { enterpriseId }) => {\n    const domains = await ctx.db\n      .query(\"EnterpriseDomain\")\n      .withIndex(\"enterprise_id\", (idx) => idx.eq(\"enterpriseId\", enterpriseId))\n      .collect();\n    for (const domain of domains) {\n      const verification = await ctx.db\n        .query(\"EnterpriseDomainVerification\")\n        .withIndex(\"domain_id\", (idx) => idx.eq(\"domainId\", domain._id))\n        .first();\n      if (verification) {\n        await ctx.db.delete(verification._id);\n      }\n      await ctx.db.delete(domain._id);\n    }\n    const secrets = await ctx.db\n      .query(\"EnterpriseSecret\")\n      .withIndex(\"enterprise_id\", (idx) => idx.eq(\"enterpriseId\", enterpriseId))\n      .collect();\n    for (const secret of secrets) {\n      await ctx.db.delete(secret._id);\n    }\n    await ctx.db.delete(enterpriseId);\n    return null;\n  },\n});\n"],"mappings":"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"}

package/dist/component/public/enterprise/domains.d.ts

@@ -0,0 +1,174 @@
+declare namespace domains_d_exports {
+  export { enterpriseDomainAdd, enterpriseDomainDelete, enterpriseDomainList, enterpriseDomainVerificationDelete, enterpriseDomainVerificationGet, enterpriseDomainVerificationUpsert, enterpriseDomainVerify };
+}
+/**
+ * Link a domain to an enterprise record, or update an existing link.
+ *
+ * If the domain is already attached to a different enterprise, an
+ * `ENTERPRISE_DOMAIN_TAKEN` error is thrown. If the domain already exists for
+ * this enterprise, it is updated in place (e.g. toggling `isPrimary`). When
+ * `isPrimary` is `true`, any previously primary domain on the same enterprise
+ * is demoted. The first domain added to an enterprise becomes primary by default.
+ *
+ * @param args.enterpriseId - The ID of the enterprise to attach the domain to.
+ * @param args.groupId - The ID of the root group that owns the enterprise.
+ * @param args.domain - The domain name to link (e.g. `"acme.com"`).
+ * @param args.isPrimary - Whether this domain should be set as the primary domain for the enterprise. Defaults to `true` for the first domain.
+ * @returns The ID of the created or updated `EnterpriseDomain` document.
+ *
+ * @example
+ * ```ts
+ * const domainId = await ctx.runMutation(
+ *   components.auth.enterprise.enterpriseDomainAdd,
+ *   {
+ *     enterpriseId,
+ *     groupId: orgGroupId,
+ *     domain: "acme.com",
+ *     isPrimary: true,
+ *   },
+ * );
+ * ```
+ */
+declare const enterpriseDomainAdd: any;
+/**
+ * List all domains linked to a specific enterprise.
+ *
+ * Returns all `EnterpriseDomain` documents associated with the given enterprise,
+ * queried via the `enterprise_id` index. The result includes both verified and
+ * unverified domains.
+ *
+ * @param args.enterpriseId - The ID of the enterprise whose domains to list.
+ * @returns An array of enterprise domain documents.
+ *
+ * @example
+ * ```ts
+ * const domains = await ctx.runQuery(
+ *   components.auth.enterprise.enterpriseDomainList,
+ *   { enterpriseId },
+ * );
+ * for (const d of domains) {
+ *   console.log(d.domain, d.isPrimary, d.verifiedAt);
+ * }
+ * ```
+ */
+declare const enterpriseDomainList: any;
+/**
+ * Remove a linked enterprise domain and its associated verification record.
+ *
+ * Deletes the `EnterpriseDomain` document and, if one exists, the related
+ * `EnterpriseDomainVerification` record. This is a permanent deletion.
+ *
+ * @param args.domainId - The document ID of the enterprise domain to remove.
+ * @returns `null` on success.
+ *
+ * @example
+ * ```ts
+ * await ctx.runMutation(
+ *   components.auth.enterprise.enterpriseDomainDelete,
+ *   { domainId },
+ * );
+ * ```
+ */
+declare const enterpriseDomainDelete: any;
+/**
+ * Retrieve the pending domain verification record for a given enterprise domain.
+ *
+ * Returns the `EnterpriseDomainVerification` document associated with the
+ * specified domain, or `null` if no verification has been initiated.
+ *
+ * @param args.domainId - The document ID of the enterprise domain whose verification to retrieve.
+ * @returns The domain verification document, or `null` if none exists.
+ *
+ * @example
+ * ```ts
+ * const verification = await ctx.runQuery(
+ *   components.auth.enterprise.enterpriseDomainVerificationGet,
+ *   { domainId },
+ * );
+ * if (verification) {
+ *   console.log(verification.recordName, verification.expiresAt);
+ * }
+ * ```
+ */
+declare const enterpriseDomainVerificationGet: any;
+/**
+ * Create or update a domain verification challenge for an enterprise domain.
+ *
+ * If a verification record already exists for the domain, all fields are
+ * updated in place (e.g. to rotate the token). Otherwise a new record is
+ * created. The caller is responsible for generating the DNS record name,
+ * token, and token hash.
+ *
+ * @param args.enterpriseId - The ID of the enterprise that owns the domain.
+ * @param args.groupId - The ID of the root group that owns the enterprise.
+ * @param args.domainId - The document ID of the enterprise domain to verify.
+ * @param args.domain - The domain name string (e.g. `"acme.com"`).
+ * @param args.recordName - The DNS TXT record name to be published (e.g. `"_convex-verify.acme.com"`).
+ * @param args.token - The plaintext verification token value.
+ * @param args.tokenHash - A hash of the verification token for secure storage.
+ * @param args.requestedAt - Epoch timestamp (ms) when the verification was requested.
+ * @param args.expiresAt - Epoch timestamp (ms) after which the challenge expires.
+ * @returns The ID of the created or updated `EnterpriseDomainVerification` document.
+ *
+ * @example
+ * ```ts
+ * const verificationId = await ctx.runMutation(
+ *   components.auth.enterprise.enterpriseDomainVerificationUpsert,
+ *   {
+ *     enterpriseId,
+ *     groupId: orgGroupId,
+ *     domainId,
+ *     domain: "acme.com",
+ *     recordName: "_convex-verify.acme.com",
+ *     token: "abc123",
+ *     tokenHash: "sha256:...",
+ *     requestedAt: Date.now(),
+ *     expiresAt: Date.now() + 7 * 24 * 60 * 60 * 1000,
+ *   },
+ * );
+ * ```
+ */
+declare const enterpriseDomainVerificationUpsert: any;
+/**
+ * Delete the pending domain verification record for an enterprise domain.
+ *
+ * Removes the `EnterpriseDomainVerification` document associated with the
+ * given domain, effectively cancelling the verification challenge. If no
+ * verification record exists, this is a no-op.
+ *
+ * @param args.domainId - The document ID of the enterprise domain whose verification to delete.
+ * @returns `null` on success.
+ *
+ * @example
+ * ```ts
+ * await ctx.runMutation(
+ *   components.auth.enterprise.enterpriseDomainVerificationDelete,
+ *   { domainId },
+ * );
+ * ```
+ */
+declare const enterpriseDomainVerificationDelete: any;
+/**
+ * Mark an enterprise domain as verified and clean up the verification record.
+ *
+ * Sets the `verifiedAt` timestamp on the domain document and deletes the
+ * associated `EnterpriseDomainVerification` record (if any). Throws an
+ * `INVALID_PARAMETERS` error if the domain document does not exist.
+ *
+ * @param args.domainId - The document ID of the enterprise domain to mark as verified.
+ * @param args.verifiedAt - Epoch timestamp (ms) at which the domain was verified.
+ * @returns The updated enterprise domain document with the `verifiedAt` field set.
+ *
+ * @example
+ * ```ts
+ * const verifiedDomain = await ctx.runMutation(
+ *   components.auth.enterprise.enterpriseDomainVerify,
+ *   { domainId, verifiedAt: Date.now() },
+ * );
+ * console.log("Domain verified:", verifiedDomain.domain);
+ * ```
+ */
+declare const enterpriseDomainVerify: any;
+//#endregion
+export { domains_d_exports, enterpriseDomainAdd, enterpriseDomainDelete, enterpriseDomainList, enterpriseDomainVerificationDelete, enterpriseDomainVerificationGet, enterpriseDomainVerificationUpsert, enterpriseDomainVerify };
+//# sourceMappingURL=domains.d.ts.map

package/dist/component/public/enterprise/domains.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domains.d.ts","names":[],"sources":["../../../../src/component/public/enterprise/domains.ts"],"mappings":";;;;;;;;;;;;;;;AAgCA;;;;;AA2EA;;;;;AA4BA;;;;;AAoCA;cA3Ia,mBAAA;;;;AA2Lb;;;;;AA4CA;;;;;AAmCA;;;;;;;;cA/La,oBAAA;;;;;;;;;;;;;;;;;;cA4BA,sBAAA;;;;;;;;;;;;;;;;;;;;;cAoCA,+BAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgDA,kCAAA;;;;;;;;;;;;;;;;;;;cA4CA,kCAAA;;;;;;;;;;;;;;;;;;;;;cAmCA,sBAAA"}