polen 0.11.0-next.14 → 0.11.0-next.15

package/src/lib/schema-definition/schema-definition.ts

@@ -0,0 +1,115 @@
+import { S } from '#lib/kit-temp/effect'
+import { ParseResult } from 'effect'
+import { GraphQLSchema } from 'graphql'
+import { buildASTSchema, parse, printSchema } from 'graphql'
+import { graphqlAst } from './graphql-ast.js'
+
+// ============================================================================
+// Schema
+// ============================================================================
+
+export const SchemaDefinition = S.transformOrFail(
+  graphqlAst,
+  S.instanceOf(GraphQLSchema),
+  {
+    strict: true,
+    decode: (ast, options, astSchema) => {
+      try {
+        const schema = buildASTSchema(ast)
+        return ParseResult.succeed(schema)
+      } catch (error) {
+        return ParseResult.fail(
+          new ParseResult.Type(astSchema, ast, `Invalid GraphQL AST: ${error}`),
+        )
+      }
+    },
+    encode: (schema, options, astSchema) => {
+      try {
+        const sdl = printSchema(schema)
+        const ast = parse(sdl)
+        return ParseResult.succeed(ast)
+      } catch (error) {
+        return ParseResult.fail(
+          new ParseResult.Type(astSchema, schema, `Failed to serialize schema: ${error}`),
+        )
+      }
+    },
+  },
+).annotations({
+  identifier: 'SchemaDefinition',
+  title: 'Schema Definition',
+  description: 'A GraphQL schema definition',
+  equivalence: () => (a, b) => printSchema(a) === printSchema(b),
+})
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export type SchemaDefinition = S.Schema.Type<typeof SchemaDefinition>
+
+// ============================================================================
+// SDL Codec
+// ============================================================================
+
+// Create a transformation from SDL string to AST
+const sdlToAst = S.transformOrFail(
+  S.String,
+  graphqlAst,
+  {
+    strict: true,
+    decode: (sdl, _, astSchema) => {
+      try {
+        const ast = parse(sdl)
+        return ParseResult.succeed(ast)
+      } catch (error) {
+        return ParseResult.fail(
+          new ParseResult.Type(astSchema, sdl, `Invalid SDL syntax: ${error}`),
+        )
+      }
+    },
+    encode: (ast) => ParseResult.succeed(printSchema(buildASTSchema(ast))),
+  },
+)
+
+// Compose the transformations: String -> AST -> GraphQLSchema
+const sdlSchema = S.compose(sdlToAst, SchemaDefinition).annotations({
+  identifier: 'SDLSchema',
+  title: 'SDL Schema',
+  description: 'SDL string representation of a GraphQL schema',
+})
+
+// Export SDL codec
+export const sdl = {
+  decode: S.decodeSync(sdlSchema),
+  encode: S.encodeSync(sdlSchema),
+}
+
+// ============================================================================
+// Guards
+// ============================================================================
+
+export const is = S.is(SchemaDefinition)
+
+// ============================================================================
+// Codecs
+// ============================================================================
+
+export const decode = S.decode(SchemaDefinition)
+export const decodeSync = S.decodeSync(SchemaDefinition)
+export const encode = S.encode(SchemaDefinition)
+
+// ============================================================================
+// State Predicates
+// ============================================================================
+
+export const isEmpty = (schema: SchemaDefinition): boolean => {
+  const sdlString = sdl.encode(schema)
+  return sdlString === '' || sdlString === 'type Query'
+}
+
+// ============================================================================
+// Equivalence
+// ============================================================================
+
+export const equivalence = S.equivalence(SchemaDefinition)

package/src/lib/semver/$$.ts

@@ -0,0 +1 @@
+export * from './semver.js'

package/src/lib/semver/$.test.ts

@@ -0,0 +1,179 @@
+import { Effect } from 'effect'
+import { describe, expect, test } from 'vitest'
+import { Test } from '../../../tests/unit/helpers/test.js'
+import { Semver } from './$.js'
+
+// dprint-ignore
+Test.suite<{ input: string; sync: boolean; shouldSucceed: boolean; major?: number; minor?: number; patch?: number; prerelease?: (string | number)[]; build?: string[] }>('decoding', [
+  { name: 'creates a valid semver from string',         input: '1.2.3',                    sync: false, shouldSucceed: true,  major: 1, minor: 2, patch: 3 },
+  { name: 'fails on invalid semver string',             input: 'invalid',                  sync: false, shouldSucceed: false },
+  { name: 'creates a valid semver synchronously',       input: '1.2.3-beta.1+build.123',   sync: true,  shouldSucceed: true,  major: 1, minor: 2, patch: 3, prerelease: ['beta', 1], build: ['build', '123'] },
+], async ({ input, sync, shouldSucceed, major, minor, patch, prerelease, build }) => {
+  if (sync) {
+    const version = Semver.decodeSync(input)
+    expect(Semver.getMajor(version)).toBe(major)
+    expect(Semver.getMinor(version)).toBe(minor)
+    expect(Semver.getPatch(version)).toBe(patch)
+    if (prerelease) {
+      expect(Semver.getPrerelease(version)).toEqual(prerelease)
+    }
+    if (build) {
+      expect(Semver.getBuild(version)).toEqual(build)
+    }
+  } else {
+    if (shouldSucceed) {
+      const version = Semver.decodeSync(input)
+      expect(Semver.getMajor(version)).toBe(major)
+      expect(Semver.getMinor(version)).toBe(minor)
+      expect(Semver.getPatch(version)).toBe(patch)
+    } else {
+      await expect(Effect.runPromise(Semver.decode(input))).rejects.toThrow()
+    }
+  }
+})
+
+// dprint-ignore
+Test.suite<{ version: string; expectedTag: string; isOfficial: boolean; isPreRelease: boolean; build?: string[] }>('discriminated union', [
+  { name: 'correctly identifies official releases',                                                    version: '1.2.3',                                                                                  expectedTag: 'SemverOfficialRelease', isOfficial: true,  isPreRelease: false },
+  { name: 'correctly identifies pre-releases',                                                         version: '1.2.3-beta',                                                                             expectedTag: 'SemverPreRelease',      isOfficial: false, isPreRelease: true },
+  { name: 'handles build metadata on official release',                                                version: '1.2.3+build.123',                                                                        expectedTag: 'SemverOfficialRelease', isOfficial: true,  isPreRelease: false, build: ['build', '123'] },
+  { name: 'handles build metadata on pre-release',                                                     version: '1.2.3-beta+build.123',                                                                   expectedTag: 'SemverPreRelease',      isOfficial: false, isPreRelease: true,  build: ['build', '123'] },
+], ({ version, expectedTag, isOfficial, isPreRelease, build }) => {
+  const semver = Semver.decodeSync(version)
+  expect(semver._tag).toBe(expectedTag)
+  expect(Semver.OfficialRelease.is(semver)).toBe(isOfficial)
+  expect(Semver.PreRelease.is(semver)).toBe(isPreRelease)
+  if (build) {
+    expect(Semver.getBuild(semver)).toEqual(build)
+  }
+})
+
+// dprint-ignore
+Test.suite<{ version: string; expected: string }>('pattern matching', [
+  { name: 'matches on official release',                                                               version: '1.2.3',                                                                                  expected: 'Official: 1.2.3' },
+  { name: 'matches on pre-release',                                                                    version: '1.2.3-beta.1',                                                                           expected: 'Pre-release: 1.2.3-beta.1' },
+], ({ version, expected }) => {
+  const semver = Semver.decodeSync(version)
+  const result = Semver.match(
+    (official) => `Official: ${official.major}.${official.minor}.${official.patch}`,
+    (prerelease) =>
+      `Pre-release: ${prerelease.major}.${prerelease.minor}.${prerelease.patch}-${prerelease.prerelease.join('.')}`,
+  )(semver)
+  expect(result).toBe(expected)
+})
+
+// dprint-ignore
+Test.suite<{ method: 'order' | 'greaterThan' | 'lessThan' | 'equivalence'; v1: string; v2: string; expected: number | boolean }>('comparisons', [
+  { name: 'compares versions correctly (v1 < v2)',      method: 'order',        v1: '1.0.0', v2: '2.0.0', expected: -1 },
+  { name: 'compares versions correctly (v1 > v2)',      method: 'order',        v1: '2.0.0', v2: '1.0.0', expected: 1 },
+  { name: 'compares versions correctly (v1 = v2)',      method: 'order',        v1: '1.0.0', v2: '1.0.0', expected: 0 },
+  { name: 'checks greater than (v1 < v2)',              method: 'greaterThan',  v1: '1.0.0', v2: '2.0.0', expected: true },
+  { name: 'checks greater than (v1 > v2)',              method: 'greaterThan',  v1: '2.0.0', v2: '1.0.0', expected: false },
+  { name: 'checks less than (v1 < v2)',                 method: 'lessThan',     v1: '2.0.0', v2: '1.0.0', expected: true },
+  { name: 'checks less than (v1 > v2)',                 method: 'lessThan',     v1: '1.0.0', v2: '2.0.0', expected: false },
+  { name: 'checks equality (equal)',                    method: 'equivalence',  v1: '1.0.0', v2: '1.0.0', expected: true },
+  { name: 'checks equality (not equal)',                method: 'equivalence',  v1: '1.0.0', v2: '2.0.0', expected: false },
+], ({ method, v1, v2, expected }) => {
+  const version1 = Semver.decodeSync(v1)
+  const version2 = Semver.decodeSync(v2)
+  
+  switch (method) {
+    case 'order':
+      expect(Semver.order(version1, version2)).toBe(expected)
+      break
+    case 'greaterThan':
+      expect(Semver.greaterThan(version1)(version2)).toBe(expected)
+      break
+    case 'lessThan':
+      expect(Semver.lessThan(version1)(version2)).toBe(expected)
+      break
+    case 'equivalence':
+      expect(Semver.equivalence(version1, version2)).toBe(expected)
+      break
+  }
+})
+
+// dprint-ignore
+Test.suite<{ value: unknown; expected: boolean }>('validation', [
+  { name: 'validates 1.2.3',                                                                           value: Semver.decodeSync('1.2.3'),                                                                expected: true },
+  { name: 'validates 0.0.0',                                                                           value: Semver.decodeSync('0.0.0'),                                                                expected: true },
+  { name: 'validates 1.2.3-beta',                                                                      value: Semver.decodeSync('1.2.3-beta'),                                                           expected: true },
+  { name: 'validates 1.2.3+build',                                                                     value: Semver.decodeSync('1.2.3+build'),                                                          expected: true },
+  { name: 'rejects plain object',                                                                      value: { major: 1, minor: 2, patch: 3 },                                                          expected: false },
+  { name: 'rejects string',                                                                            value: '1.2.3',                                                                                    expected: false },
+  { name: 'rejects null',                                                                              value: null,                                                                                       expected: false },
+], ({ value, expected }) => {
+  expect(Semver.is(value)).toBe(expected)
+})
+
+// dprint-ignore
+Test.suite<{ level: 'major' | 'minor' | 'patch'; expected: string }>('utilities', [
+  { name: 'increments major version',                                                                  level: 'major',                                                                                    expected: '2.0.0' },
+  { name: 'increments minor version',                                                                  level: 'minor',                                                                                    expected: '1.3.0' },
+  { name: 'increments patch version',                                                                  level: 'patch',                                                                                    expected: '1.2.4' },
+], ({ level, expected }) => {
+  const v = Semver.decodeSync('1.2.3')
+  const incremented = Semver.increment(v, level)
+  expect(incremented.version.toString()).toBe(expected)
+})
+
+// dprint-ignore
+Test.suite<{ test: 'sort' | 'min' | 'max' | 'equivalence'; versions?: string[]; v1?: string; v2?: string; expected: string[] | string | boolean }>('ordering and equivalence', [
+  { name: 'provides correct ordering',                   test: 'sort',        versions: ['2.0.0', '1.0.0', '1.5.0'],         expected: ['1.0.0', '1.5.0', '2.0.0'] },
+  { name: 'finds min',                                   test: 'min',         v1: '1.0.0', v2: '2.0.0',                      expected: '1.0.0' },
+  { name: 'finds max',                                   test: 'max',         v1: '1.0.0', v2: '2.0.0',                      expected: '2.0.0' },
+  { name: 'checks structural equality (equal)',          test: 'equivalence', v1: '1.0.0', v2: '1.0.0',                      expected: true },
+  { name: 'checks structural equality (not equal)',      test: 'equivalence', v1: '1.0.0', v2: '2.0.0',                      expected: false },
+], ({ test, versions, v1, v2, expected }) => {
+  switch (test) {
+    case 'sort': {
+      const versionObjs = versions!.map(v => Semver.decodeSync(v))
+      const sorted = [...versionObjs].sort(Semver.order)
+      expect(sorted.map(v => v.version.toString())).toEqual(expected)
+      break
+    }
+    case 'min': {
+      const version1 = Semver.decodeSync(v1!)
+      const version2 = Semver.decodeSync(v2!)
+      const result = Semver.min(version1, version2)
+      expect(result.version.toString()).toBe(expected)
+      break
+    }
+    case 'max': {
+      const version1 = Semver.decodeSync(v1!)
+      const version2 = Semver.decodeSync(v2!)
+      const result = Semver.max(version1, version2)
+      expect(result.version.toString()).toBe(expected)
+      break
+    }
+    case 'equivalence': {
+      const version1 = Semver.decodeSync(v1!)
+      const version2 = Semver.decodeSync(v2!)
+      expect(Semver.equivalence(version1, version2)).toBe(expected)
+      break
+    }
+  }
+})
+
+// dprint-ignore
+Test.suite<{ major: number; minor: number; patch: number; prerelease?: string | undefined; build?: string | undefined; expected: string | undefined }>('fromParts', [
+  { name: 'creates version from basic parts',                                                          major: 1, minor: 2, patch: 3,                                                                      expected: '1.2.3' },
+  { name: 'creates version with prerelease',                                                           major: 1, minor: 2, patch: 3, prerelease: 'beta.1',                                               expected: '1.2.3-beta.1' },
+  { name: 'creates version with prerelease and build',                                                 major: 1, minor: 2, patch: 3, prerelease: 'beta.1', build: 'build.123',                           expected: '1.2.3-beta.1+build.123' },
+  { name: 'creates version with build only',                                                           major: 1, minor: 2, patch: 3, prerelease: undefined, build: 'build.123',                          expected: '1.2.3+build.123' },
+], ({ major, minor, patch, prerelease, build, expected }) => {
+  const version = Semver.fromParts(major, minor, patch, prerelease, build)
+  expect(version.version.toString()).toBe(expected)
+})
+
+// dprint-ignore
+Test.suite<{ range: string; expected: boolean }>('satisfies', [
+  { name: 'satisfies >=1.0.0',                                                                         range: '>=1.0.0',                                                                                  expected: true },
+  { name: 'satisfies ^1.0.0',                                                                          range: '^1.0.0',                                                                                   expected: true },
+  { name: 'satisfies ~1.2.0',                                                                          range: '~1.2.0',                                                                                   expected: true },
+  { name: 'does not satisfy 2.x',                                                                      range: '2.x',                                                                                      expected: false },
+  { name: 'invalid range returns false',                                                               range: 'invalid range',                                                                            expected: false },
+], ({ range, expected }) => {
+  const v = Semver.decodeSync('1.2.3')
+  expect(Semver.satisfies(v, range)).toBe(expected)
+})

package/src/lib/semver/$.ts

@@ -0,0 +1 @@
+export * as Semver from './semver.js'

package/src/lib/semver/official-release.ts

@@ -0,0 +1,50 @@
+import { S } from '#lib/kit-temp/effect'
+import { Version as VltVersion } from '@vltpkg/semver'
+
+// ============================================================================
+// Schema
+// ============================================================================
+
+export const OfficialRelease = S.TaggedStruct('SemverOfficialRelease', {
+  major: S.Number,
+  minor: S.Number,
+  patch: S.Number,
+  build: S.optional(S.Array(S.String)),
+  version: S.instanceOf(VltVersion),
+}).annotations({
+  identifier: 'OfficialRelease',
+  title: 'Official Release',
+  description: 'A semantic version that is an official release (no pre-release identifiers)',
+})
+
+// ============================================================================
+// Type
+// ============================================================================
+
+export type OfficialRelease = S.Schema.Type<typeof OfficialRelease>
+
+// ============================================================================
+// Constructors
+// ============================================================================
+
+export const make = OfficialRelease.make
+
+// ============================================================================
+// Type Guard
+// ============================================================================
+
+export const is = S.is(OfficialRelease)
+
+// ============================================================================
+// Codec
+// ============================================================================
+
+export const decode = S.decode(OfficialRelease)
+export const decodeSync = S.decodeSync(OfficialRelease)
+export const encode = S.encode(OfficialRelease)
+
+// ============================================================================
+// Equivalence
+// ============================================================================
+
+export const equivalence = S.equivalence(OfficialRelease)

package/src/lib/semver/pre-release.ts

@@ -0,0 +1,51 @@
+import { S } from '#lib/kit-temp/effect'
+import { Version as VltVersion } from '@vltpkg/semver'
+
+// ============================================================================
+// Schema
+// ============================================================================
+
+export const PreRelease = S.TaggedStruct('SemverPreRelease', {
+  major: S.Number,
+  minor: S.Number,
+  patch: S.Number,
+  prerelease: S.NonEmptyArray(S.Union(S.String, S.Number)),
+  build: S.optional(S.Array(S.String)),
+  version: S.instanceOf(VltVersion),
+}).annotations({
+  identifier: 'PreRelease',
+  title: 'Pre-Release',
+  description: 'A semantic version with pre-release identifiers',
+})
+
+// ============================================================================
+// Type
+// ============================================================================
+
+export type PreRelease = S.Schema.Type<typeof PreRelease>
+
+// ============================================================================
+// Constructors
+// ============================================================================
+
+export const make = PreRelease.make
+
+// ============================================================================
+// Type Guard
+// ============================================================================
+
+export const is = S.is(PreRelease)
+
+// ============================================================================
+// Codec
+// ============================================================================
+
+export const decode = S.decode(PreRelease)
+export const decodeSync = S.decodeSync(PreRelease)
+export const encode = S.encode(PreRelease)
+
+// ============================================================================
+// Equivalence
+// ============================================================================
+
+export const equivalence = S.equivalence(PreRelease)

package/src/lib/semver/semver.ts

@@ -0,0 +1,200 @@
+import { S } from '#lib/kit-temp/effect'
+import { Range as VltRange, Version as VltVersion } from '@vltpkg/semver'
+import { Effect, Equivalence, Order, ParseResult } from 'effect'
+import * as OfficialRelease from './official-release.js'
+import * as PreRelease from './pre-release.js'
+
+// Re-export member modules as namespaces
+export { OfficialRelease, PreRelease }
+
+// ============================================================================
+// Schema
+// ============================================================================
+
+const SemverUnion = S.Union(OfficialRelease.OfficialRelease, PreRelease.PreRelease).annotations({
+  identifier: 'Semver',
+  title: 'Semantic Version',
+  description: 'A semantic version following SemVer specification',
+})
+
+/**
+ * Schema for semantic version strings using @vltpkg/semver for validation
+ */
+export const Semver = S.transformOrFail(
+  S.String,
+  SemverUnion,
+  {
+    strict: true,
+    decode: (value, _, ast) => {
+      try {
+        const version = VltVersion.parse(value)
+        const base = {
+          major: version.major,
+          minor: version.minor,
+          patch: version.patch,
+          build: version.build && version.build.length > 0 ? version.build : undefined,
+          version,
+        }
+
+        if (version.prerelease && version.prerelease.length > 0) {
+          return ParseResult.succeed({
+            _tag: 'SemverPreRelease' as const,
+            ...base,
+            prerelease: version.prerelease as [string | number, ...(string | number)[]],
+          })
+        } else {
+          return ParseResult.succeed({
+            _tag: 'SemverOfficialRelease' as const,
+            ...base,
+          })
+        }
+      } catch (error) {
+        return ParseResult.fail(
+          new ParseResult.Type(ast, value, `Invalid semver: ${error}`),
+        )
+      }
+    },
+    encode: (semver) => ParseResult.succeed(semver.version.toString()),
+  },
+)
+
+// ============================================================================
+// Type
+// ============================================================================
+
+export type Semver = S.Schema.Type<typeof Semver>
+
+// ============================================================================
+// Constructors
+// ============================================================================
+
+// Note: No make constructor for transform schemas - use fromString or fromParts instead
+
+// ============================================================================
+// Ordering
+// ============================================================================
+
+export const order: Order.Order<Semver> = Order.make((a, b) => a.version.compare(b.version))
+
+export const min = Order.min(order)
+
+export const max = Order.max(order)
+
+export const lessThan = Order.lessThan(order)
+
+export const greaterThan = Order.greaterThan(order)
+
+// ============================================================================
+// Equivalence
+// ============================================================================
+
+export const equivalence: Equivalence.Equivalence<Semver> = Equivalence.make((a, b) =>
+  a.version.compare(b.version) === 0
+)
+
+// ============================================================================
+// Type Guard
+// ============================================================================
+
+export const is = S.is(Semver)
+
+// ============================================================================
+// State Predicates
+// ============================================================================
+
+// Note: isPreRelease is now handled by checking the _tag or using PreRelease.is
+
+// ============================================================================
+// Codec
+// ============================================================================
+
+export const decode = S.decode(Semver)
+export const decodeSync = S.decodeSync(Semver)
+export const encode = S.encode(Semver)
+
+// ============================================================================
+// Importers
+// ============================================================================
+
+export const fromString = S.decodeSync(Semver)
+
+/**
+ * Create semver from parts
+ */
+export const fromParts = (
+  major: number,
+  minor: number = 0,
+  patch: number = 0,
+  prerelease?: string,
+  build?: string,
+): Semver => {
+  const prereleaseStr = prerelease ? `-${prerelease}` : ''
+  const buildStr = build ? `+${build}` : ''
+  const version = `${major}.${minor}.${patch}${prereleaseStr}${buildStr}`
+  return fromString(version)
+}
+
+// ============================================================================
+// Domain Logic
+// ============================================================================
+
+/**
+ * Get the major version number
+ */
+export const getMajor = (version: Semver): number => version.major
+
+/**
+ * Get the minor version number
+ */
+export const getMinor = (version: Semver): number => version.minor
+
+/**
+ * Get the patch version number
+ */
+export const getPatch = (version: Semver): number => version.patch
+
+/**
+ * Get the prerelease identifiers
+ */
+export const getPrerelease = (version: Semver): ReadonlyArray<string | number> | undefined =>
+  version._tag === 'SemverPreRelease' ? version.prerelease : undefined
+
+/**
+ * Get the build metadata
+ */
+export const getBuild = (version: Semver): ReadonlyArray<string> | undefined => version.build
+
+/**
+ * Increment a version
+ */
+export const increment = (
+  version: Semver,
+  release: 'major' | 'minor' | 'patch' | 'premajor' | 'preminor' | 'prepatch' | 'prerelease',
+  identifier?: string,
+): Semver => {
+  // Create a copy since inc modifies in place
+  const copy = VltVersion.parse(version.version.toString())
+  const incremented = copy.inc(release, identifier)
+  return fromString(incremented.toString())
+}
+
+/**
+ * Check if version satisfies a range
+ */
+export const satisfies = (version: Semver, range: string): boolean => {
+  try {
+    const vltRange = new VltRange(range)
+    return version.version.satisfies(vltRange)
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Pattern match on Semver variants
+ */
+export const match = <$A>(
+  onOfficialRelease: (release: OfficialRelease.OfficialRelease) => $A,
+  onPreRelease: (preRelease: PreRelease.PreRelease) => $A,
+) =>
+(semver: Semver): $A => semver._tag === 'SemverOfficialRelease' ? onOfficialRelease(semver) : onPreRelease(semver)

package/src/lib/services-crud/$$.ts

@@ -0,0 +1,4 @@
+export * from './browser-ro.js'
+export * from './filesystem.js'
+export * from './memory.js'
+export * from './service.js'

package/src/lib/services-crud/$.ts

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