fix: treeshakability issues

.changeset/quick-seas-crash.md

@@ -0,0 +1,8 @@
+---
+'@pubkey-cache/resolver': patch
+'@pubkey-cache/server': patch
+'@pubkey-cache/core': patch
+'@pubkey-cache/react': patch
+---
+
+fix: treeshakability issues

examples/node-redis/package.json

@@ -33,7 +33,7 @@
     "@solana/web3.js": "^1.98.2",
     "esrun": "^3.2.26",
     "h3": "^1.15.1",
-    "helius-sdk": "^1.4.2",
+    "helius-sdk": "^1.5.1",
     "ioredis": "^5.5.0",
     "listhen": "^1.9.0",
     "picocolors": "^1.1.1",

examples/node-redis/src/commands/command-resolver-sync-all.ts

@@ -9,7 +9,7 @@ import { resolve } from './resolve'
 
 export const commandResolverSyncAll: Command = {
   action: async () => {
-    const { resolvers, verbose, heliusApiKey } = getConfig()
+    const { resolvers, heliusApiKey } = getConfig()
     const context = getContext()
     const startTime = new Date().getTime()
     const results: string[] = []

packages/resolver/package.json

@@ -74,16 +74,16 @@
         "maintained node versions"
     ],
     "dependencies": {
-        "@solana/kit": "^2.1.0",
-        "gill": "^0.9.0",
-        "zod": "^3.24.3"
+        "valibot": "^1.1.0"
     },
     "devDependencies": {
-        "helius-sdk": "^1.4.2",
+        "helius-sdk": "^1.5.1",
         "unstorage": "^1.15.0"
     },
     "peerDependencies": {
-        "helius-sdk": "^1.4.2",
+        "@solana/kit": "^2.1.0",
+        "gill": "^0.9.0",
+        "helius-sdk": "^1.5.1",
         "typescript": ">=5",
         "unstorage": "^1.15.0"
     },

packages/resolver/src/__tests__/create-resolver-context-helius-instance-test.ts

@@ -2,7 +2,7 @@ import { Helius } from 'helius-sdk';
 
 import { createResolverContextHelius } from '../resolvers/helius/create-resolver-context-helius';
 import { createResolverContextHeliusInstance } from '../resolvers/helius/create-resolver-context-helius-instance';
-import { type ResolverContextHelius } from '../resolvers/helius/types/resolver-context-helius';
+import { ResolverContextHelius } from '../resolvers/helius/types/resolver-context-helius';
 
 describe('create-resolver-context-helius-instance', () => {
     const heliusApiKey = '00000000-0000-0000-0000-000000000000';

packages/resolver/src/__tests__/create-resolver-context-helius-test.ts

@@ -68,18 +68,9 @@ describe('create-resolver-context-helius', () => {
             const config: ResolverConfigHeliusInput = { heliusApiKey: '00000000000000000000000000000000' };
 
             // ASSERT
-            expect(() => createResolverContextHelius(config)).toThrowErrorMatchingInlineSnapshot(`
-            "[
-              {
-                "validation": "uuid",
-                "code": "invalid_string",
-                "message": "Invalid uuid",
-                "path": [
-                  "heliusApiKey"
-                ]
-              }
-            ]"
-        `);
+            expect(() => createResolverContextHelius(config)).toThrowErrorMatchingInlineSnapshot(
+                `"Invalid UUID: Received "00000000000000000000000000000000""`,
+            );
         });
 
         it('should thrown an error with an invalid cluster', () => {
@@ -92,22 +83,9 @@ describe('create-resolver-context-helius', () => {
             };
 
             // ASSERT
-            expect(() => createResolverContextHelius(config)).toThrowErrorMatchingInlineSnapshot(`
-            "[
-              {
-                "received": "testnet",
-                "code": "invalid_enum_value",
-                "options": [
-                  "mainnet-beta",
-                  "devnet"
-                ],
-                "path": [
-                  "heliusCluster"
-                ],
-                "message": "Invalid enum value. Expected 'mainnet-beta' | 'devnet', received 'testnet'"
-              }
-            ]"
-        `);
+            expect(() => createResolverContextHelius(config)).toThrowErrorMatchingInlineSnapshot(
+                `"Invalid type: Expected ("mainnet-beta" | "devnet") but received "testnet""`,
+            );
         });
     });
 });

packages/resolver/src/__tests__/create-resolver-context-solana-client-test.ts

@@ -69,45 +69,19 @@ describe('create-resolver-context-solana-client', () => {
             const config: ResolverConfigSolanaClientInput = { endpoint: 'this is not a url' };
 
             // ASSERT
-            expect(() => createResolverContextSolanaClient(config)).toThrowErrorMatchingInlineSnapshot(`
-                "[
-                  {
-                    "validation": "url",
-                    "code": "invalid_string",
-                    "message": "Invalid url",
-                    "path": [
-                      "endpoint"
-                    ]
-                  },
-                  {
-                    "validation": "url",
-                    "code": "invalid_string",
-                    "message": "Invalid url",
-                    "path": [
-                      "endpointWs"
-                    ]
-                  }
-                ]"
-            `);
+            expect(() => createResolverContextSolanaClient(config)).toThrowErrorMatchingInlineSnapshot(
+                `"Invalid URL: Received "this is not a url""`,
+            );
         });
         it('should thrown an error with an invalid endpointWs', () => {
             expect.assertions(1);
             // ARRANGE
             const config: ResolverConfigSolanaClientInput = { endpoint, endpointWs: 'not a ws endpoint' };
 
             // ASSERT
-            expect(() => createResolverContextSolanaClient(config)).toThrowErrorMatchingInlineSnapshot(`
-                "[
-                  {
-                    "validation": "url",
-                    "code": "invalid_string",
-                    "message": "Invalid url",
-                    "path": [
-                      "endpointWs"
-                    ]
-                  }
-                ]"
-            `);
+            expect(() => createResolverContextSolanaClient(config)).toThrowErrorMatchingInlineSnapshot(
+                `"Invalid URL: Received "not a ws endpoint""`,
+            );
         });
 
         it('should thrown an error with an invalid cluster', () => {
@@ -120,24 +94,9 @@ describe('create-resolver-context-solana-client', () => {
             };
 
             // ASSERT
-            expect(() => createResolverContextSolanaClient(config)).toThrowErrorMatchingInlineSnapshot(`
-                "[
-                  {
-                    "received": "random",
-                    "code": "invalid_enum_value",
-                    "options": [
-                      "mainnet",
-                      "devnet",
-                      "testnet",
-                      "localnet"
-                    ],
-                    "path": [
-                      "cluster"
-                    ],
-                    "message": "Invalid enum value. Expected 'mainnet' | 'devnet' | 'testnet' | 'localnet', received 'random'"
-                  }
-                ]"
-            `);
+            expect(() => createResolverContextSolanaClient(config)).toThrowErrorMatchingInlineSnapshot(
+                `"Invalid type: Expected ("mainnet" | "devnet" | "testnet" | "localnet") but received "random""`,
+            );
         });
     });
 });

packages/resolver/src/resolvers/helius/get-resolver-config-helius-schema.ts

@@ -0,0 +1,11 @@
+import * as v from 'valibot';
+
+import { ResolverConfigType } from '../../types/resolver-config-type';
+
+export function getResolverConfigHeliusSchema() {
+    return v.object({
+        heliusApiKey: v.pipe(v.string(), v.uuid()),
+        heliusCluster: v.optional(v.union([v.literal('mainnet-beta'), v.literal('devnet')]), 'mainnet-beta'),
+        type: v.optional(v.literal(ResolverConfigType.Helius), ResolverConfigType.Helius),
+    });
+}

packages/resolver/src/resolvers/helius/types/resolver-config-helius-type.ts

@@ -1,5 +1,5 @@
-import { z } from 'zod';
+import * as v from 'valibot';
 
-import { ResolverConfigHeliusSchema } from '../resolver-config-helius-schema';
+import { getResolverConfigHeliusSchema } from '../get-resolver-config-helius-schema';
 
-export type ResolverConfigHeliusType = z.infer<typeof ResolverConfigHeliusSchema>;
+export type ResolverConfigHeliusType = v.InferOutput<ReturnType<typeof getResolverConfigHeliusSchema>>;

packages/resolver/src/resolvers/helius/validate-resolver-config-helius.ts

@@ -1,7 +1,9 @@
-import { ResolverConfigHeliusSchema } from './resolver-config-helius-schema';
+import * as v from 'valibot';
+
+import { getResolverConfigHeliusSchema } from './get-resolver-config-helius-schema';
 import { ResolverConfigHelius } from './types/resolver-config-helius';
 import { ResolverConfigHeliusInput } from './types/resolver-config-helius-input';
 
 export function validateResolverConfigHelius(input: ResolverConfigHeliusInput): ResolverConfigHelius {
-    return ResolverConfigHeliusSchema.parse(input);
+    return v.parse(getResolverConfigHeliusSchema(), input);
 }

packages/resolver/src/resolvers/solana-client/get-resolver-config-solana-client-schema.ts

@@ -0,0 +1,15 @@
+import * as v from 'valibot';
+
+import { ResolverConfigType } from '../../types/resolver-config-type';
+
+export function getResolverConfigSolanaClientSchema() {
+    return v.object({
+        cluster: v.optional(
+            v.union([v.literal('mainnet'), v.literal('devnet'), v.literal('testnet'), v.literal('localnet')]),
+            'mainnet',
+        ),
+        endpoint: v.pipe(v.string(), v.url()),
+        endpointWs: v.optional(v.pipe(v.string(), v.url())),
+        type: v.optional(v.literal(ResolverConfigType.SolanaClient), ResolverConfigType.SolanaClient),
+    });
+}

packages/resolver/src/resolvers/solana-client/types/resolver-config-solana-client-type.ts

@@ -1,5 +1,5 @@
-import { z } from 'zod';
+import * as v from 'valibot';
 
-import { ResolverConfigSolanaClientSchema } from '../resolver-config-solana-client-schema';
+import { getResolverConfigSolanaClientSchema } from '../get-resolver-config-solana-client-schema';
 
-export type ResolverConfigSolanaClientType = z.infer<typeof ResolverConfigSolanaClientSchema>;
+export type ResolverConfigSolanaClientType = v.InferOutput<ReturnType<typeof getResolverConfigSolanaClientSchema>>;

packages/resolver/src/resolvers/solana-client/validate-resolver-config-solana-client.ts

@@ -1,9 +1,11 @@
-import { ResolverConfigSolanaClientSchema } from './resolver-config-solana-client-schema';
+import * as v from 'valibot';
+
+import { getResolverConfigSolanaClientSchema } from './get-resolver-config-solana-client-schema';
 import { ResolverConfigSolanaClient } from './types/resolver-config-solana-client';
 import { ResolverConfigSolanaClientInput } from './types/resolver-config-solana-client-input';
 
 export function validateResolverConfigSolanaClient(input: ResolverConfigSolanaClientInput): ResolverConfigSolanaClient {
-    return ResolverConfigSolanaClientSchema.parse({
+    return v.parse(getResolverConfigSolanaClientSchema(), {
         ...input,
         endpointWs: input.endpointWs ?? input.endpoint.replace('http', 'ws'),
     });

packages/server/package.json

@@ -86,7 +86,7 @@
     },
     "peerDependencies": {
         "h3": "^1.15.1",
-        "helius-sdk": "^1.4.2",
+        "helius-sdk": "^1.5.1",
         "listhen": "^1.9.0",
         "typescript": ">=5",
         "unstorage": "^1.15.0"