feat: Add resource samples (#183)

* Rename code-sample module to samples

* Move some types to syntax.ts

* Rename syntax types

* Add createResourceSample

* Add resourceSamples and resourceSampleDefinitions to Blueprint

* Generate resource samples

* ci: Format code

* ci: Generate code

* Add test for resource samples

* Update resource-sample-definitions.ts

* ci: Generate code

* Add missing continue

* Fix continue

* ci: Generate code

---------

Co-authored-by: Seam Bot <seambot@getseam.com>

Author: razor-x

src/lib/blueprint.ts

@@ -1,14 +1,5 @@
 import { z } from 'zod'
 
-import {
-  type CodeSample,
-  CodeSampleDefinitionSchema,
-  createCodeSample,
-} from './code-sample/index.js'
-import type {
-  CodeSampleDefinition,
-  CodeSampleSyntax,
-} from './code-sample/schema.js'
 import { findCommonOpenapiSchemaProperties } from './openapi/find-common-openapi-schema-properties.js'
 import { flattenOpenapiSchema } from './openapi/flatten-openapi-schema.js'
 import {
@@ -26,6 +17,17 @@ import type {
   OpenapiPaths,
   OpenapiSchema,
 } from './openapi/types.js'
+import {
+  type CodeSample,
+  type CodeSampleDefinition,
+  CodeSampleDefinitionSchema,
+  createCodeSample,
+  createResourceSample,
+  type ResourceSample,
+  type ResourceSampleDefinition,
+  ResourceSampleDefinitionSchema,
+  type SyntaxName,
+} from './samples/index.js'
 import {
   mapOpenapiToSeamAuthMethod,
   type SeamAuthMethod,
@@ -66,6 +68,7 @@ export interface Resource {
   isDraft: boolean
   draftMessage: string
   propertyGroups: Record<string, PropertyGroup>
+  resourceSamples: ResourceSample[]
 }
 
 interface PropertyGroup {
@@ -413,11 +416,15 @@ export type Method = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH'
 
 interface Context extends Required<BlueprintOptions> {
   codeSampleDefinitions: CodeSampleDefinition[]
+  resourceSampleDefinitions: ResourceSampleDefinition[]
   validActionAttemptTypes: string[]
 }
 
 export const TypesModuleSchema = z.object({
   codeSampleDefinitions: z.array(CodeSampleDefinitionSchema).default([]),
+  resourceSampleDefinitions: z
+    .array(ResourceSampleDefinitionSchema)
+    .default([]),
   // TODO: Import and use openapi zod schema here
   openapi: z.any(),
 })
@@ -427,14 +434,15 @@ export type TypesModuleInput = z.input<typeof TypesModuleSchema>
 export type TypesModule = z.output<typeof TypesModuleSchema>
 
 export interface BlueprintOptions {
-  formatCode?: (content: string, syntax: CodeSampleSyntax) => Promise<string>
+  formatCode?: (content: string, syntax: SyntaxName) => Promise<string>
 }
 
 export const createBlueprint = async (
   typesModule: TypesModuleInput,
   { formatCode = async (content) => content }: BlueprintOptions = {},
 ): Promise<Blueprint> => {
-  const { codeSampleDefinitions } = TypesModuleSchema.parse(typesModule)
+  const { codeSampleDefinitions, resourceSampleDefinitions } =
+    TypesModuleSchema.parse(typesModule)
 
   // TODO: Move openapi to TypesModuleSchema
   const openapi = typesModule.openapi as Openapi
@@ -445,6 +453,7 @@ export const createBlueprint = async (
 
   const context: Context = {
     codeSampleDefinitions,
+    resourceSampleDefinitions,
     formatCode,
     validActionAttemptTypes,
   }
@@ -458,18 +467,19 @@ export const createBlueprint = async (
     ),
   )
 
-  const resources = createResources(openapiSchemas, routes)
-  const actionAttempts = createActionAttempts(
+  const resources = await createResources(openapiSchemas, routes, context)
+  const actionAttempts = await createActionAttempts(
     openapi.components.schemas,
     routes,
+    context,
   )
 
   return {
     title: openapi.info.title,
     routes,
     resources,
     pagination: createPagination(pagination),
-    events: createEvents(openapiSchemas, resources, routes),
+    events: await createEvents(openapiSchemas, resources, routes, context),
     actionAttempts,
   }
 }
@@ -1074,59 +1084,66 @@ const createPagination = (
   }
 }
 
-export const createResources = (
+export const createResources = async (
   schemas: Openapi['components']['schemas'],
   routes: Route[],
-): Record<string, Resource> => {
-  return Object.entries(schemas).reduce<Record<string, Resource>>(
-    (resources, [schemaName, schema]) => {
-      const { success: isValidEventSchema, data: parsedEvent } =
-        EventResourceSchema.safeParse(schema)
-      if (isValidEventSchema) {
-        const commonProperties = findCommonOpenapiSchemaProperties(
-          parsedEvent.oneOf,
-        )
-        const eventSchema: OpenapiSchema = {
-          'x-route-path': parsedEvent['x-route-path'],
-          properties: commonProperties,
-          type: 'object',
-        }
-        return {
-          ...resources,
-          [schemaName]: createResource(schemaName, eventSchema, routes),
-        }
+  context: Context,
+): Promise<Record<string, Resource>> => {
+  const resources: Record<string, Resource> = {}
+  for (const [schemaName, schema] of Object.entries(schemas)) {
+    const { success: isValidEventSchema, data: parsedEvent } =
+      EventResourceSchema.safeParse(schema)
+
+    if (isValidEventSchema) {
+      const commonProperties = findCommonOpenapiSchemaProperties(
+        parsedEvent.oneOf,
+      )
+      const eventSchema: OpenapiSchema = {
+        'x-route-path': parsedEvent['x-route-path'],
+        properties: commonProperties,
+        type: 'object',
       }
+      resources[schemaName] = await createResource(
+        schemaName,
+        eventSchema,
+        routes,
+        context,
+      )
+      continue
+    }
 
-      const { success: isValidResourceSchema } =
-        ResourceSchema.safeParse(schema)
-      if (isValidResourceSchema) {
-        return {
-          ...resources,
-          [schemaName]: createResource(schemaName, schema, routes),
-        }
-      }
+    const { success: isValidResourceSchema } = ResourceSchema.safeParse(schema)
+    if (isValidResourceSchema) {
+      resources[schemaName] = await createResource(
+        schemaName,
+        schema,
+        routes,
+        context,
+      )
+      continue
+    }
+  }
 
-      return resources
-    },
-    {},
-  )
+  return resources
 }
 
-const createResource = (
+const createResource = async (
   schemaName: string,
   schema: OpenapiSchema,
   routes: Route[],
-): Resource => {
+  context: Context,
+): Promise<Resource> => {
   const routePath = validateRoutePath(
     schemaName,
     schema['x-route-path'],
     routes,
   )
 
   const propertyGroups = getPropertyGroupsForResource(schema)
+  const resourceType = schemaName
 
-  return {
-    resourceType: schemaName,
+  const resource: Omit<Resource, 'resourceSamples'> = {
+    resourceType,
     properties: createProperties(
       schema.properties ?? {},
       [schemaName],
@@ -1142,6 +1159,23 @@ const createResource = (
     draftMessage: schema['x-draft'] ?? '',
     propertyGroups,
   }
+
+  return {
+    ...resource,
+    resourceSamples: await Promise.all(
+      context.resourceSampleDefinitions
+        .filter(
+          (resourceSample) => resourceSample.resource_type === resourceType,
+        )
+        .map(
+          async (resourceSampleDefinition) =>
+            await createResourceSample(resourceSampleDefinition, {
+              resource,
+              formatCode: context.formatCode,
+            }),
+        ),
+    ),
+  }
 }
 
 const validateRoutePath = (
@@ -1620,11 +1654,12 @@ export const getPreferredMethod = (
   return semanticMethod
 }
 
-const createEvents = (
+const createEvents = async (
   schemas: Openapi['components']['schemas'],
   resources: Record<string, Resource>,
   routes: Route[],
-): EventResource[] => {
+  context: Context,
+): Promise<EventResource[]> => {
   const eventSchema = schemas['event']
   if (
     eventSchema == null ||
@@ -1635,8 +1670,8 @@ const createEvents = (
     return []
   }
 
-  return eventSchema.oneOf
-    .map((schema) => {
+  const events = await Promise.all(
+    eventSchema.oneOf.map(async (schema) => {
       if (
         typeof schema !== 'object' ||
         schema.properties?.['event_type']?.enum?.[0] == null
@@ -1650,18 +1685,21 @@ const createEvents = (
       )
 
       return {
-        ...createResource('event', schema, routes),
+        ...(await createResource('event', schema, routes, context)),
         eventType,
         targetResourceType: targetResourceType ?? null,
       }
-    })
-    .filter((event): event is EventResource => event !== null)
+    }),
+  )
+
+  return events.filter((event): event is EventResource => event !== null)
 }
 
-const createActionAttempts = (
+const createActionAttempts = async (
   schemas: Openapi['components']['schemas'],
   routes: Route[],
-): ActionAttempt[] => {
+  context: Context,
+): Promise<ActionAttempt[]> => {
   const actionAttemptSchema = schemas['action_attempt']
   if (
     actionAttemptSchema == null ||
@@ -1692,62 +1730,65 @@ const createActionAttempts = (
     }
   }
 
-  return Array.from(schemasByActionType.entries()).map(
-    ([actionType, schemas]) => {
-      const mergedProperties: Record<string, OpenapiSchema> = {}
-
-      const allPropertyKeys = new Set<string>()
-      for (const schema of schemas) {
-        if (schema.properties != null) {
-          Object.keys(schema.properties).forEach((key) =>
-            allPropertyKeys.add(key),
-          )
+  return await Promise.all(
+    Array.from(schemasByActionType.entries()).map(
+      async ([actionType, schemas]) => {
+        const mergedProperties: Record<string, OpenapiSchema> = {}
+
+        const allPropertyKeys = new Set<string>()
+        for (const schema of schemas) {
+          if (schema.properties != null) {
+            Object.keys(schema.properties).forEach((key) =>
+              allPropertyKeys.add(key),
+            )
+          }
         }
-      }
 
-      for (const propKey of allPropertyKeys) {
-        const propDefinitions = schemas
-          .filter((schema) => schema.properties?.[propKey] != null)
-          .map((schema) => schema.properties?.[propKey])
+        for (const propKey of allPropertyKeys) {
+          const propDefinitions = schemas
+            .filter((schema) => schema.properties?.[propKey] != null)
+            .map((schema) => schema.properties?.[propKey])
 
-        if (propDefinitions.length === 0) continue
+          if (propDefinitions.length === 0) continue
 
-        const nonNullableDefinition = propDefinitions.find((prop) => {
-          if (prop == null) return false
+          const nonNullableDefinition = propDefinitions.find((prop) => {
+            if (prop == null) return false
 
-          return !('nullable' in prop && prop.nullable === true)
-        })
+            return !('nullable' in prop && prop.nullable === true)
+          })
 
-        mergedProperties[propKey] =
-          nonNullableDefinition ?? propDefinitions[0] ?? {}
-      }
+          mergedProperties[propKey] =
+            nonNullableDefinition ?? propDefinitions[0] ?? {}
+        }
 
-      // Ensure standard status field
-      mergedProperties['status'] = {
-        ...mergedProperties['status'],
-        type: 'string',
-        enum: ['success', 'pending', 'error'],
-      }
+        // Ensure standard status field
+        mergedProperties['status'] = {
+          ...mergedProperties['status'],
+          type: 'string',
+          enum: ['success', 'pending', 'error'],
+        }
 
-      const schemaWithMergedProperties: OpenapiSchema = {
-        ...(actionAttemptSchema['x-route-path'] != null && {
-          'x-route-path': actionAttemptSchema['x-route-path'],
-        }),
-        ...schemas[0],
-        properties: mergedProperties,
-      }
+        const schemaWithMergedProperties: OpenapiSchema = {
+          ...(actionAttemptSchema['x-route-path'] != null && {
+            'x-route-path': actionAttemptSchema['x-route-path'],
+          }),
+          ...schemas[0],
+          properties: mergedProperties,
+        }
 
-      const resource = createResource(
-        'action_attempt',
-        schemaWithMergedProperties,
-        routes,
-      )
+        const resource = await createResource(
+          'action_attempt',
+          schemaWithMergedProperties,
+          routes,
+          context,
+        )
 
-      return {
-        ...resource,
-        resourceType: 'action_attempt',
-        actionAttemptType: actionType,
-      }
-    },
+        return {
+          ...resource,
+          resourceType: 'action_attempt',
+          actionAttemptType: actionType,
+        }
+      },
+    ),
   )
 }