polen 0.11.0-next.11 → 0.11.0-next.13

package/src/lib/schema-lifecycle/$.test.ts

@@ -0,0 +1,222 @@
+import { buildSchema } from 'graphql'
+import { describe, expect, it } from 'vitest'
+import { SchemaLifecycle } from './$.js'
+
+// Test fixtures
+const date1 = new Date('2024-01-01')
+const date2 = new Date('2024-02-01')
+const schemas = {
+  simple: buildSchema(`type Query { hello: String } type User { id: ID! name: String! }`),
+  extended: buildSchema(`type Query { hello: String world: String } type User { id: ID! name: String! email: String }`),
+  withIVStats: buildSchema(`
+    type Query { hello: String world: String }
+    type User { id: ID! name: String! email: String }
+    type IVStats { hp: Int! attack: Int! defense: Int! }
+  `),
+}
+
+// Helper to create initial changelog
+const createChangelog = (schema = schemas.simple, date = date1): any => [{
+  type: 'InitialChangeSet',
+  date,
+  after: { version: 'v1', data: schema },
+}]
+
+describe('create', () => {
+  it('creates lifecycle for initial schema types and fields', () => {
+    const lifecycle = SchemaLifecycle.create(createChangelog() as any) as any
+
+    // Check types
+    const userTypes = Object.keys(lifecycle.data).filter(t => !['String', 'ID', 'Boolean', 'Int', 'Float'].includes(t))
+    expect(userTypes).toEqual(['Query', 'User'])
+
+    // Check Query fields
+    expect(Object.keys(lifecycle.data.Query.fields)).toEqual(['hello'])
+    expect(lifecycle.data.Query.fields.hello).toMatchObject({
+      name: 'hello',
+      events: [{ type: 'added', date: date1 }],
+    })
+
+    // Check User fields
+    expect(Object.keys(lifecycle.data.User.fields)).toEqual(['id', 'name'])
+    expect(lifecycle.data.User.fields.id.name).toBe('id')
+    expect(lifecycle.data.User.fields.name.name).toBe('name')
+  })
+
+  it('handles TYPE_ADDED with fields populated', () => {
+    const changelog = [
+      ...createChangelog(),
+      {
+        type: 'IntermediateChangeSet',
+        date: date2,
+        before: { version: 'v1', data: schemas.simple },
+        after: { version: 'v2', data: schemas.withIVStats },
+        changes: [{
+          type: 'TYPE_ADDED',
+          path: 'IVStats',
+          criticality: { level: 'NON_BREAKING' } as any,
+          message: 'Type IVStats was added',
+          meta: { addedTypeName: 'IVStats' },
+        }],
+      },
+    ]
+    const lifecycle = SchemaLifecycle.create(changelog as any) as any
+    const ivStats = lifecycle.data.IVStats
+
+    expect(ivStats.kind).toBe('Object')
+    expect(Object.keys(ivStats.fields)).toEqual(['hp', 'attack', 'defense'])
+    expect(ivStats.fields.hp).toMatchObject({ name: 'hp', events: [{ type: 'added', date: date2 }] })
+  })
+
+  it('handles field additions', () => {
+    const changelog = [
+      ...createChangelog(),
+      {
+        type: 'IntermediateChangeSet',
+        date: date2,
+        before: { version: 'v1', data: schemas.simple },
+        after: { version: 'v2', data: schemas.extended },
+        changes: [
+          {
+            type: 'FIELD_ADDED',
+            path: 'Query.world',
+            criticality: { level: 'NON_BREAKING' } as any,
+            message: '',
+            meta: { typeName: 'Query', addedFieldName: 'world', typeType: 'object type' },
+          },
+          {
+            type: 'FIELD_ADDED',
+            path: 'User.email',
+            criticality: { level: 'NON_BREAKING' } as any,
+            message: '',
+            meta: { typeName: 'User', addedFieldName: 'email', typeType: 'object type' },
+          },
+        ],
+      },
+    ]
+    const lifecycle = SchemaLifecycle.create(changelog as any) as any
+
+    expect(lifecycle.data.Query.fields.world).toMatchObject({ name: 'world', events: [{ type: 'added', date: date2 }] })
+    expect(lifecycle.data.User.fields.email).toMatchObject({ name: 'email', events: [{ type: 'added', date: date2 }] })
+  })
+
+  it('handles field additions to existing type without explicit FIELD_ADDED events', () => {
+    // Simulate a scenario where fields are added but no explicit FIELD_ADDED events exist
+    const trainerV1 = buildSchema(`
+      type Query { hello: String }
+      type Trainer { 
+        id: ID!
+        name: String!
+      }
+    `)
+    const trainerV2 = buildSchema(`
+      type Query { hello: String }
+      type Trainer { 
+        id: ID!
+        name: String!
+        battleRecord: String!
+        money: Int!
+      }
+    `)
+
+    const changelog = [
+      { type: 'InitialChangeSet', date: date1, after: { version: 'v1', data: trainerV1 } },
+      {
+        type: 'IntermediateChangeSet',
+        date: date2,
+        before: { version: 'v1', data: trainerV1 },
+        after: { version: 'v2', data: trainerV2 },
+        changes: [
+          // No explicit FIELD_ADDED events - simulating the missing lifecycle scenario
+        ],
+      },
+    ]
+    const lifecycle = SchemaLifecycle.create(changelog as any) as any
+
+    // Original fields should have lifecycle info
+    expect(lifecycle.data.Trainer.fields.id).toMatchObject({ name: 'id', events: [{ type: 'added', date: date1 }] })
+    expect(lifecycle.data.Trainer.fields.name).toMatchObject({ name: 'name', events: [{ type: 'added', date: date1 }] })
+    
+    // New fields without FIELD_ADDED events should NOT have lifecycle info
+    expect(lifecycle.data.Trainer.fields.battleRecord).toBeUndefined()
+    expect(lifecycle.data.Trainer.fields.money).toBeUndefined()
+  })
+})
+
+describe('serialization', () => {
+  it('preserves field lifecycle data through serialization', () => {
+    const schema = buildSchema(`
+      type Query { hello: String }
+      type IVStats {
+        hp: Int!
+        attack: Int!
+        defense: Int!
+      }
+    `)
+
+    const changelog = [{
+      type: 'InitialChangeSet',
+      date: date1,
+      after: { version: 'v1', data: schema },
+    }]
+
+    const lifecycle = SchemaLifecycle.create(changelog as any)
+
+    // Check fields exist before serialization
+    const ivStatsBefore = lifecycle.data['IVStats'] as any
+    expect(ivStatsBefore?.fields).toBeDefined()
+    expect(Object.keys(ivStatsBefore?.fields || {})).toEqual(['hp', 'attack', 'defense'])
+
+    // Serialize and deserialize
+    const json = SchemaLifecycle.toJson(lifecycle)
+    const parsed = SchemaLifecycle.fromJson(json)
+
+    // Check fields exist after deserialization
+    const ivStatsAfter = parsed.data['IVStats'] as any
+    expect(ivStatsAfter?.fields).toBeDefined()
+    expect(Object.keys(ivStatsAfter?.fields || {})).toEqual(['hp', 'attack', 'defense'])
+  })
+
+  it('toJson/fromJson preserves dates and nullifies schemas', () => {
+    const lifecycle = SchemaLifecycle.create(createChangelog())
+    const json = SchemaLifecycle.toJson(lifecycle)
+    const parsed = SchemaLifecycle.fromJson(json) as any
+
+    // Check dates are preserved
+    expect(parsed.data.Query.events[0].date).toEqual(date1)
+    expect(parsed.data.Query.fields.hello.events[0].date).toEqual(date1)
+
+    // Check schemas are nullified by codec
+    expect(parsed.data.Query.events[0].schema.data).toBeNull()
+    expect(parsed.data.Query.fields.hello.events[0].schema.data).toBeNull()
+  })
+})
+
+describe('getters', () => {
+  const schemaWithoutUser = buildSchema(`type Query { hello: String }`)
+  const changelog = [
+    ...createChangelog(),
+    {
+      type: 'IntermediateChangeSet',
+      date: date2,
+      before: { version: 'v1', data: schemas.simple },
+      after: { version: 'v2', data: schemaWithoutUser },
+      changes: [{
+        type: 'TYPE_REMOVED',
+        path: 'User',
+        criticality: { level: 'BREAKING' } as any,
+        message: '',
+        meta: { removedTypeName: 'User' },
+      }],
+    },
+  ]
+  const lifecycle = SchemaLifecycle.create(changelog as any)
+
+  it('getTypeLifecycle', () => expect(SchemaLifecycle.getTypeLifecycle(lifecycle, 'Query')?.name).toBe('Query'))
+  it('getTypeAddedDate', () => expect(SchemaLifecycle.getTypeAddedDate(lifecycle, 'Query')).toEqual(date1))
+  it('getTypeRemovedDate', () => expect(SchemaLifecycle.getTypeRemovedDate(lifecycle, 'User')).toEqual(date2))
+  it('isTypeCurrentlyAvailable', () => {
+    expect(SchemaLifecycle.isTypeCurrentlyAvailable(lifecycle, 'Query')).toBe(true)
+    expect(SchemaLifecycle.isTypeCurrentlyAvailable(lifecycle, 'User')).toBe(false)
+  })
+})

package/src/lib/schema-lifecycle/$.ts

@@ -0,0 +1 @@
+export * as SchemaLifecycle from './$$.js'

package/src/lib/schema-lifecycle/FieldLifecycle.ts

@@ -0,0 +1,18 @@
+import type { NonEmptyArray } from '#lib/kit-temp'
+import type { LifecycleEventBase } from './LifecycleEvent.js'
+
+/**
+ * Field lifecycle for object and interface types
+ */
+export interface FieldLifecycle {
+  name: string
+  events: NonEmptyArray<LifecycleEventBase>
+}
+
+/**
+ * Input field lifecycle for input object types
+ */
+export interface InputFieldLifecycle {
+  name: string
+  events: NonEmptyArray<LifecycleEventBase>
+}

package/src/lib/schema-lifecycle/LifecycleEvent.ts

@@ -0,0 +1,27 @@
+import type { GraphqlChangeset } from '#lib/graphql-changeset'
+
+/**
+ * Base lifecycle event
+ */
+export interface LifecycleEventBase {
+  date: Date
+  /**
+   * null if unlinked. Soemthing external should use `date` to link changeSet.
+   */
+  changeSet: GraphqlChangeset.ChangeSet | null
+  schema: GraphqlChangeset.VersionableSchema
+}
+
+/**
+ * Event when a type or field is added
+ */
+export interface AddedEvent extends LifecycleEventBase {
+  type: 'added'
+}
+
+/**
+ * Event when a type or field is removed
+ */
+export interface RemovedEvent extends LifecycleEventBase {
+  type: 'removed'
+}

package/src/lib/schema-lifecycle/NamedTypeLifecycle.ts

@@ -0,0 +1,96 @@
+import { Grafaid } from '#lib/grafaid'
+import type { NonEmptyArray } from '#lib/kit-temp'
+import type { FieldLifecycle, InputFieldLifecycle } from './FieldLifecycle.js'
+import type { AddedEvent, LifecycleEventBase } from './LifecycleEvent.js'
+
+/**
+ * Union of all possible named type lifecycles
+ */
+export type NamedTypeLifecycle =
+  | ObjectTypeLifecycle
+  | UnionTypeLifecycle
+  | InterfaceTypeLifecycle
+  | EnumTypeLifecycle
+  | ScalarTypeLifecycle
+  | InputObjectTypeLifecycle
+
+/**
+ * Object type lifecycle with fields
+ */
+export interface ObjectTypeLifecycle extends NamedTypeLifecycleBase {
+  kind: Grafaid.Schema.TypeKindName.Object
+  fields: Record<string, FieldLifecycle>
+}
+
+/**
+ * Union type lifecycle (no fields)
+ */
+export interface UnionTypeLifecycle extends NamedTypeLifecycleBase {
+  kind: Grafaid.Schema.TypeKindName.Union
+}
+
+/**
+ * Interface type lifecycle with fields
+ */
+export interface InterfaceTypeLifecycle extends NamedTypeLifecycleBase {
+  kind: Grafaid.Schema.TypeKindName.Interface
+  fields: Record<string, FieldLifecycle>
+}
+
+/**
+ * Enum type lifecycle (no values for now)
+ */
+export interface EnumTypeLifecycle extends NamedTypeLifecycleBase {
+  kind: Grafaid.Schema.TypeKindName.Enum
+}
+
+/**
+ * Scalar type lifecycle (no fields or values)
+ */
+export interface ScalarTypeLifecycle extends NamedTypeLifecycleBase {
+  kind: Grafaid.Schema.TypeKindName.Scalar
+}
+
+/**
+ * Input object type lifecycle with input fields
+ */
+export interface InputObjectTypeLifecycle extends NamedTypeLifecycleBase {
+  kind: Grafaid.Schema.TypeKindName.InputObject
+  fields: Record<string, InputFieldLifecycle>
+}
+
+/**
+ * Base interface for all named type lifecycles
+ */
+export interface NamedTypeLifecycleBase {
+  name: string
+  events: NonEmptyArray<LifecycleEventBase>
+}
+
+/**
+ * Create a named type lifecycle with the correct type-specific structure
+ */
+export const createNamedTypeLifecycle = (
+  typeName: string,
+  kind: Grafaid.Schema.TypeKindName,
+  addedEvent: AddedEvent,
+): NamedTypeLifecycle => {
+  const base = { name: typeName, events: [addedEvent] as NonEmptyArray<LifecycleEventBase> }
+
+  switch (kind) {
+    case Grafaid.Schema.TypeKindNameEnum.Object:
+      return { ...base, kind, fields: {} } as ObjectTypeLifecycle
+    case Grafaid.Schema.TypeKindNameEnum.Interface:
+      return { ...base, kind, fields: {} } as InterfaceTypeLifecycle
+    case Grafaid.Schema.TypeKindNameEnum.InputObject:
+      return { ...base, kind, fields: {} } as InputObjectTypeLifecycle
+    case Grafaid.Schema.TypeKindNameEnum.Union:
+      return { ...base, kind } as UnionTypeLifecycle
+    case Grafaid.Schema.TypeKindNameEnum.Enum:
+      return { ...base, kind } as EnumTypeLifecycle
+    case Grafaid.Schema.TypeKindNameEnum.Scalar:
+      return { ...base, kind } as ScalarTypeLifecycle
+    default:
+      throw new Error(`Unknown type kind: ${kind}`)
+  }
+}

package/src/lib/schema-lifecycle/SchemaLifecycle.ts

@@ -0,0 +1,85 @@
+import { Grafaid } from '#lib/grafaid/$'
+import { GraphqlChange } from '#lib/graphql-change'
+import { GraphqlChangeset } from '#lib/graphql-changeset'
+import type { GraphQLSchema } from 'graphql'
+import { SuperJSON } from 'superjson'
+import * as Handlers from './handlers.js'
+import type { NamedTypeLifecycle } from './NamedTypeLifecycle.js'
+
+const superjson = new SuperJSON()
+
+// Register codec to handle GraphQL schemas - convert to null to avoid circular refs
+superjson.registerCustom({
+  isApplicable: (v): v is GraphQLSchema => v?.constructor?.name === 'GraphQLSchema',
+  serialize: () => null,
+  deserialize: () => null,
+}, 'GraphQLSchema')
+
+// Register codec to handle ChangeSet objects - convert to null as per type design
+superjson.registerCustom({
+  isApplicable: GraphqlChangeset.isChangeSet,
+  serialize: () => ({ value: null }),
+  deserialize: () => null,
+}, 'ChangeSet')
+
+/**
+ * Schema lifecycle data structure containing all types and their evolution
+ */
+export interface SchemaLifecycle {
+  data: Record<string, NamedTypeLifecycle>
+}
+
+export type SupportedChange =
+  | GraphqlChange.Group.TypeOperation
+  | GraphqlChange.Group.FieldOperation
+  | GraphqlChange.Group.InputFieldOperation
+
+/**
+ * Build schema lifecycle data from changesets
+ */
+export const create = (
+  changelog: GraphqlChangeset.ChangelogLinked,
+): SchemaLifecycle => {
+  const data: SchemaLifecycle['data'] = {}
+
+  // Process changesets in chronological order (oldest to newest)
+  for (const changeSet of changelog) {
+    if (GraphqlChangeset.isInitialChangeSetLinked(changeSet)) {
+      Handlers.createInitialTypeLifecycles(data, changeSet)
+      continue
+    }
+
+    for (const change of changeSet.changes) {
+      if (
+        GraphqlChange.Group.isTypeOperation(change)
+        || GraphqlChange.Group.isFieldOperation(change)
+        || GraphqlChange.Group.isInputFieldOperation(change)
+      ) {
+        const changeGroupType = GraphqlChange.Group.getType(change)
+        const handler = Handlers[changeGroupType]
+        handler(data, change as any, changeSet)
+      }
+    }
+  }
+
+  return { data }
+}
+
+/**
+ * Convert SchemaLifecycle to JSON string
+ */
+export const toJson = (lifecycle: SchemaLifecycle, options?: { pretty?: boolean }): string => {
+  const isPretty = options?.pretty ?? true
+  if (isPretty) {
+    const serialized = superjson.serialize(lifecycle)
+    return JSON.stringify(serialized, null, 2)
+  }
+  return superjson.stringify(lifecycle)
+}
+
+/**
+ * Parse SchemaLifecycle from JSON string
+ */
+export const fromJson = (json: string): SchemaLifecycle => {
+  return superjson.parse(json)
+}

package/src/lib/schema-lifecycle/SchemaLink.ts

@@ -0,0 +1,40 @@
+// import type { GraphQLSchema } from 'graphql'
+
+// /**
+//  * Schema link for versioned schemas
+//  */
+// export interface VersionedSchemaLink {
+//   type: 'versioned'
+//   version: string
+//   data: GraphQLSchema | null
+// }
+
+// /**
+//  * Schema link for unversioned/global schemas
+//  */
+// export interface UnversionedSchemaLink {
+//   type: 'unversioned'
+//   data: GraphQLSchema | null
+// }
+
+// /**
+//  * Schema link can be either versioned or unversioned
+//  */
+// export type SchemaLink = VersionedSchemaLink | UnversionedSchemaLink
+
+// /**
+//  * Create a schema link based on version
+//  */
+// export const createSchemaLink = (version: string | null): SchemaLink => {
+//   if (version === null) {
+//     return {
+//       type: 'unversioned',
+//       data: null,
+//     }
+//   }
+//   return {
+//     type: 'versioned',
+//     version,
+//     data: null,
+//   }
+// }