@spaceinvoices/react-ui 0.4.11 → 0.4.31

package/src/generate-schemas.ts

@@ -5,22 +5,52 @@ import path from "node:path";
 const SCHEMAS_DIR = "./src/generated/schemas";
 const GENERATED_DIR = "./generated";
 
-type SchemaGroups = {
-  [key: string]: string[];
+type OperationSchemaEntry = {
+  alias: string;
+  schemaName: string;
+  groupName: string;
 };
 
-// Helper to get group name from schema name
-const getGroupName = (schemaName: string): string => {
+// Helper to get group name from schema name / alias
+const getGroupName = (schemaName: string, alias?: string): string => {
   // Remove _Body and extract the resource name (e.g., Customer from createCustomer)
-  return schemaName.replace(/(create|patch|update|delete)([A-Z][a-zA-Z]+)_Body/, "$2").toLowerCase();
-};
+  if (schemaName.endsWith("_Body")) {
+    return schemaName.replace(/(create|patch|update|delete)([A-Z][a-zA-Z]+)_Body/, "$2").toLowerCase();
+  }
+
+  if (alias) {
+    return alias
+      .replace(/^(create|patch|update|delete|register|upload|send|preview|render|accept|add|start|authorize|sync|void)/, "")
+      .toLowerCase();
+  }
 
-// Helper to format operation name
-const formatOperationName = (operationType: string, resourceName: string): string => {
-  // Convert to proper case format (e.g., createCustomer)
-  return `${operationType}${resourceName}`;
+  return schemaName.toLowerCase();
 };
 
+function extractOperationSchemaEntries(fullContent: string): OperationSchemaEntry[] {
+  const endpointBlockRegex = /  \{[\s\S]*?\n  \},?/g;
+  const dedupedEntries = new Map<string, OperationSchemaEntry>();
+
+  for (const block of fullContent.match(endpointBlockRegex) ?? []) {
+    const aliasMatch = block.match(/alias:\s*"([^"]+)"/);
+    const bodySchemaMatch = block.match(/type:\s*"Body",[\s\S]*?schema:\s*((?:[A-Z][A-Za-z0-9_]*|[a-z][A-Za-z0-9]*_Body))/);
+
+    if (!aliasMatch || !bodySchemaMatch) {
+      continue;
+    }
+
+    const alias = aliasMatch[1];
+    const schemaName = bodySchemaMatch[1];
+    dedupedEntries.set(alias, {
+      alias,
+      schemaName,
+      groupName: getGroupName(schemaName, alias),
+    });
+  }
+
+  return [...dedupedEntries.values()];
+}
+
 async function main() {
   // Ensure directories exist
   await fs.mkdir(SCHEMAS_DIR, { recursive: true });
@@ -70,6 +100,21 @@ async function main() {
   // Fix Zod v3 record syntax - z.record(z.string()) -> z.record(z.string(), z.any())
   content = content.replace(/z\.record\(z\.string\(\)\)/g, "z.record(z.string(), z.any())");
 
+  // Fix nullable enums emitted as z.enum([... , null]), which newer Zod typings reject.
+  content = content.replace(/z\.enum\(\[([\s\S]*?)\]\)/g, (match, values) => {
+    if (!/\bnull\b/.test(values)) {
+      return match;
+    }
+
+    const enumValues = values
+      .split(",")
+      .map((value: string) => value.trim())
+      .filter((value: string) => value.length > 0 && value !== "null")
+      .join(", ");
+
+    return `z.union([z.enum([${enumValues}]), z.null()])`;
+  });
+
   // Remove .default({}) from metadata fields to keep them truly optional
   // When using .optional().default({}), Zod infers the type as required since it always has a value after parsing
   // We want metadata to be optional in the form type to match SDK types
@@ -85,13 +130,6 @@ async function main() {
   content = content.replace(/: EuTaxRules,/g, ": z.any().optional(),");
   content = content.replace(/z\.array\(EntityBankAccount\)/g, "z.array(z.any())");
 
-  // Extract just the schema definitions
-  const schemaMatch = content.match(/export const schemas = {([^}]+)}/s);
-  if (!schemaMatch) {
-    throw new Error("Could not find schema definitions in generated file");
-  }
-  const schemaSection = schemaMatch[1];
-
   // Helper function to find schema dependencies (schemas referenced by other schemas)
   function findSchemaDependencies(schemaName: string, fullContent: string): string[] {
     const dependencies: string[] = [];
@@ -117,30 +155,50 @@ async function main() {
     return dependencies;
   }
 
-  // Parse schema names and group them
-  const schemasByGroup = schemaSection
-    .split(",\n")
-    .map((line) => line.trim())
-    .filter((line) => line.includes("_Body"))
-    .map((line) => line.split(":")[0].trim())
-    .reduce<SchemaGroups>((groups, schemaName) => {
-      const groupName = getGroupName(schemaName);
-      if (!groups[groupName]) {
-        groups[groupName] = [];
+  const operationEntries = extractOperationSchemaEntries(content);
+  if (operationEntries.length === 0) {
+    throw new Error("Could not find endpoint body schemas in generated file");
+  }
+
+  const schemasByGroup = operationEntries.reduce<Record<string, OperationSchemaEntry[]>>((groups, entry) => {
+    if (!groups[entry.groupName]) {
+      groups[entry.groupName] = [];
+    }
+
+    groups[entry.groupName].push(entry);
+    return groups;
+  }, {});
+
+  // Remove previously generated schema files so stale outputs don't survive generator changes.
+  for (const file of await fs.readdir(SCHEMAS_DIR)) {
+    if (file.endsWith(".ts")) {
+      await fs.unlink(path.join(SCHEMAS_DIR, file));
+    }
+  }
+
+  // Create files for each group
+  for (const [groupName, groupEntries] of Object.entries(schemasByGroup)) {
+    const primaryEntryBySchemaName = new Map<string, OperationSchemaEntry>();
+    for (const entry of groupEntries) {
+      if (!primaryEntryBySchemaName.has(entry.schemaName)) {
+        primaryEntryBySchemaName.set(entry.schemaName, entry);
       }
+    }
 
-      // Add the main schema
-      groups[groupName].push(schemaName);
+    const schemaNames = groupEntries.reduce<string[]>((acc, entry) => {
+      if (!acc.includes(entry.schemaName)) {
+        acc.push(entry.schemaName);
+      }
 
       // Find and add dependencies
-      const deps = findSchemaDependencies(schemaName, content);
+      const deps = findSchemaDependencies(entry.schemaName, content);
       const queue = [...deps];
       const processed = new Set(deps);
 
       while (queue.length > 0) {
         const currentDep = queue.shift()!;
-        if (!groups[groupName].includes(currentDep)) {
-          groups[groupName].push(currentDep);
+        if (!acc.includes(currentDep)) {
+          acc.push(currentDep);
         }
 
         const nestedDeps = findSchemaDependencies(currentDep, content);
@@ -152,38 +210,12 @@ async function main() {
         }
       }
 
-      return groups;
-    }, {});
+      return acc;
+    }, []);
 
-  // Topological sort: ensures each schema is defined after all schemas it depends on
-  function topologicalSort(names: string[], fullContent: string): string[] {
-    const visited = new Set<string>();
-    const result: string[] = [];
-
-    function visit(name: string) {
-      if (visited.has(name)) return;
-      visited.add(name);
-      // Visit dependencies first so they appear earlier in the output
-      const deps = findSchemaDependencies(name, fullContent);
-      for (const dep of deps) {
-        if (names.includes(dep)) {
-          visit(dep);
-        }
-      }
-      result.push(name);
-    }
-
-    for (const name of names) {
-      visit(name);
-    }
-    return result;
-  }
-
-  // Create files for each group
-  for (const [groupName, schemaNames] of Object.entries(schemasByGroup)) {
     // Separate dependencies from operation schemas
-    const dependencies = schemaNames.filter((name) => !name.includes("_Body"));
-    const operations = schemaNames.filter((name) => name.includes("_Body"));
+    const dependencies = schemaNames.filter((name) => !groupEntries.some((entry) => entry.schemaName === name));
+    const operations = [...new Set(groupEntries.map((entry) => entry.schemaName))];
 
     // Topologically sort dependencies so each schema is defined after its own dependencies
     const sortedDependencies = topologicalSort(dependencies, content);
@@ -193,11 +225,9 @@ async function main() {
 
     const schemas = orderedNames
       .map((schemaName) => {
-        // Check if this is an operation schema or a dependency
-        const operationMatch = schemaName.match(/(create|patch|update|delete|register|upload|send|preview|render)/i);
-        const isOperationSchema = operationMatch && schemaName.includes("_Body");
+        const operationEntry = primaryEntryBySchemaName.get(schemaName);
 
-        if (!isOperationSchema) {
+        if (!operationEntry) {
           // This is a dependency schema, just extract its definition
           const schemaDefinitionMatch = content.match(new RegExp(`const ${schemaName} = ([^;]+);`, "s"));
           if (!schemaDefinitionMatch) {
@@ -211,20 +241,9 @@ const ${schemaName} = ${schemaDefinitionMatch[1]};
 `;
         }
 
-        // Handle operation schemas
-        const resourceMatch = schemaName.match(/[A-Z][a-zA-Z]+_Body/);
-        if (!resourceMatch) {
-          console.warn(`Warning: Invalid schema name format: ${schemaName}`);
-          return null;
-        }
-
-        const operationType = operationMatch[1].toLowerCase();
-        const resourceName = resourceMatch[0].replace("_Body", "");
-        const operationName = formatOperationName(operationType, resourceName);
-
-        const schemaDefinitionMatch = content.match(new RegExp(`const ${schemaName} = ([^;]+);`, "s"));
+        const schemaDefinitionMatch = content.match(new RegExp(`const ${operationEntry.schemaName} = ([^;]+);`, "s"));
         if (!schemaDefinitionMatch) {
-          console.warn(`Warning: Could not find schema definition for ${schemaName}`);
+          console.warn(`Warning: Could not find schema definition for ${operationEntry.schemaName}`);
           return null;
         }
 
@@ -245,35 +264,26 @@ const ${schemaName} = ${schemaDefinitionMatch[1]};
         // Add min length to country
         schemaDefinition = schemaDefinition.replace(/country: z\.string\(\)(?!\.min)/g, "country: z.string().min(1)");
 
+        const operationName = operationEntry.alias;
+
         return `
-// Schema for ${operationType} ${resourceName.toLowerCase()} operation
+// Schema for ${operationName} operation
 const ${operationName}SchemaDefinition = ${schemaDefinition};
-
-// Type for ${operationType} ${resourceName.toLowerCase()} operation
-export type ${operationName.slice(0, 1).toUpperCase() + operationName.slice(1)}Schema = z.infer<typeof ${operationName}SchemaDefinition>;
 `;
       })
       .filter((schema) => schema !== null) // Remove null entries
       .join("\n");
 
-    const exports = schemaNames
-      .filter((schemaName) => {
-        // Only export operation schemas, not dependencies
-        const operationMatch = schemaName.match(/(create|patch|update|delete|register|upload|send|preview|render)/i);
-        return operationMatch !== null && schemaName.includes("_Body");
-      })
-      .map((schemaName) => {
-        const operationMatch = schemaName.match(/(create|patch|update|delete|register|upload|send|preview|render)/i);
-        const resourceMatch = schemaName.match(/[A-Z][a-zA-Z]+_Body/);
-
-        if (!operationMatch || !resourceMatch) {
-          throw new Error(`Invalid schema name format: ${schemaName}`);
+    const exports = groupEntries
+      .map(({ alias, schemaName }) => {
+        const definitionEntry = primaryEntryBySchemaName.get(schemaName);
+        if (!definitionEntry) {
+          throw new Error(`Missing primary operation entry for ${schemaName}`);
         }
 
-        const operationType = operationMatch[1].toLowerCase();
-        const resourceName = resourceMatch[0].replace("_Body", "");
-        const operationName = formatOperationName(operationType, resourceName);
-        return `export const ${operationName}Schema = ${operationName}SchemaDefinition;`;
+        const typeName = alias.slice(0, 1).toUpperCase() + alias.slice(1);
+        return `export type ${typeName}Schema = z.infer<typeof ${definitionEntry.alias}SchemaDefinition>;
+export const ${alias}Schema = ${definitionEntry.alias}SchemaDefinition;`;
       })
       .join("\n");
 
@@ -292,12 +302,45 @@ ${exports}
 
     await fs.writeFile(path.join(SCHEMAS_DIR, `${groupName}.ts`), schemaContent);
   }
+  // Topological sort: ensures each schema is defined after all schemas it depends on
+  function topologicalSort(names: string[], fullContent: string): string[] {
+    const visited = new Set<string>();
+    const result: string[] = [];
+
+    function visit(name: string) {
+      if (visited.has(name)) return;
+      visited.add(name);
+      // Visit dependencies first so they appear earlier in the output
+      const deps = findSchemaDependencies(name, fullContent);
+      for (const dep of deps) {
+        if (names.includes(dep)) {
+          visit(dep);
+        }
+      }
+      result.push(name);
+    }
+
+    for (const name of names) {
+      visit(name);
+    }
+    return result;
+  }
 
   // Create index file - export ALL schema files (not just schemasByGroup)
-  const allSchemaFiles = (await fs.readdir(SCHEMAS_DIR))
-    .filter((f) => f.endsWith(".ts") && f !== "index.ts")
-    .map((f) => f.replace(".ts", ""))
-    .sort();
+  const normalizedSchemaFiles = new Map<string, string>();
+  for (const file of await fs.readdir(SCHEMAS_DIR)) {
+    if (!file.endsWith(".ts") || file === "index.ts") continue;
+
+    const name = file.replace(".ts", "");
+    const normalizedName = name.replace(/_/g, "").toLowerCase();
+    const existing = normalizedSchemaFiles.get(normalizedName);
+
+    if (!existing || (existing.includes("_") && !name.includes("_"))) {
+      normalizedSchemaFiles.set(normalizedName, name);
+    }
+  }
+
+  const allSchemaFiles = [...normalizedSchemaFiles.values()].sort();
 
   const indexContent = `/**
  * This file was automatically generated using 'bun generate-schemas'.

package/src/generated/schemas/acceptentityinvitation_body.ts

@@ -8,10 +8,11 @@ import { z } from 'zod';
 
 // Schemas for acceptentityinvitation_body endpoints
 
-// Dependency schema for acceptentityinvitation_body
-const acceptEntityInvitation_Body = z.object({
+// Schema for acceptEntityInvitation operation
+const acceptEntityInvitationSchemaDefinition = z.object({
   name: z.string().min(1).max(255),
   password: z.string().min(8),
 });
 
-
+export type AcceptEntityInvitationSchema = z.infer<typeof acceptEntityInvitationSchemaDefinition>;
+export const acceptEntityInvitationSchema = acceptEntityInvitationSchemaDefinition;

package/src/generated/schemas/accountwebhook.ts

@@ -0,0 +1,63 @@
+/**
+ * This file was automatically generated using 'bun generate-schemas'.
+ * Do not edit this file manually. To update, run the generator again.
+ * @generated
+ */
+
+import { z } from 'zod';
+
+// Schemas for accountwebhook endpoints
+
+// Schema for createAccountWebhook operation
+const createAccountWebhookSchemaDefinition = z.object({
+  url: z.string().max(2048).url(),
+  description: z.union([z.string().max(4000, "Description must not exceed 4000 characters"), z.null()]).optional(),
+  events: z
+    .array(
+      z.enum([
+        "white_label_subscription.subscribed",
+        "white_label_subscription.upgraded",
+        "white_label_subscription.downgrade_scheduled",
+        "white_label_subscription.downgraded",
+        "white_label_subscription.cancellation_scheduled",
+        "white_label_subscription.cancelled",
+        "white_label_subscription.renewed",
+        "white_label_subscription.expired",
+        "white_label_subscription.payment_failed",
+      ])
+    )
+    .min(1),
+  active: z.boolean().optional().default(true),
+  metadata: z.union([z.record(z.string(), z.any()), z.null()]).optional(),
+});
+
+
+// Schema for updateAccountWebhook operation
+const updateAccountWebhookSchemaDefinition = z
+  .object({
+    url: z.string().max(2048).url(),
+    description: z.union([z.string().max(4000, "Description must not exceed 4000 characters"), z.null()]),
+    events: z
+      .array(
+        z.enum([
+          "white_label_subscription.subscribed",
+          "white_label_subscription.upgraded",
+          "white_label_subscription.downgrade_scheduled",
+          "white_label_subscription.downgraded",
+          "white_label_subscription.cancellation_scheduled",
+          "white_label_subscription.cancelled",
+          "white_label_subscription.renewed",
+          "white_label_subscription.expired",
+          "white_label_subscription.payment_failed",
+        ])
+      )
+      .min(1),
+    active: z.boolean(),
+    metadata: z.union([z.record(z.string(), z.any()), z.null()]),
+  })
+  .partial();
+
+export type CreateAccountWebhookSchema = z.infer<typeof createAccountWebhookSchemaDefinition>;
+export const createAccountWebhookSchema = createAccountWebhookSchemaDefinition;
+export type UpdateAccountWebhookSchema = z.infer<typeof updateAccountWebhookSchemaDefinition>;
+export const updateAccountWebhookSchema = updateAccountWebhookSchemaDefinition;

package/src/generated/schemas/addentityuser_body.ts

@@ -8,11 +8,12 @@ import { z } from 'zod';
 
 // Schemas for addentityuser_body endpoints
 
-// Dependency schema for addentityuser_body
-const addEntityUser_Body = z.object({
+// Schema for addEntityUser operation
+const addEntityUserSchemaDefinition = z.object({
   email: z.string().email(),
   role: z.enum(["viewer", "editor", "admin"]).optional().default("editor"),
   send_invite: z.boolean().optional().default(true),
 });
 
-
+export type AddEntityUserSchema = z.infer<typeof addEntityUserSchemaDefinition>;
+export const addEntityUserSchema = addEntityUserSchemaDefinition;