polen 0.11.0-next.13 → 0.11.0-next.15

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

@@ -1,19 +0,0 @@
-export * from './FieldLifecycle.js'
-export * from './LifecycleEvent.js'
-export * from './NamedTypeLifecycle.js'
-export * from './SchemaLifecycle.js'
-
-export {
-  getFieldAddedDate,
-  getFieldLifecycle,
-  getFieldLifecycleDescription,
-  getFieldRemovedDate,
-  getTypeAddedDate,
-  getTypeLifecycle,
-  getTypeLifecycleDescription,
-  getTypeRemovedDate,
-  getTypesAddedOnDate,
-  getTypesRemovedOnDate,
-  isFieldCurrentlyAvailable,
-  isTypeCurrentlyAvailable,
-} from './utils.js'

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

@@ -1,222 +0,0 @@
-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

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

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

@@ -1,18 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,96 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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

@@ -1,40 +0,0 @@
-// 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,
-//   }
-// }