feat: add Cuid2 scalar (#2857)

* feat: add Cuid2 scalar

Closes #2399

* New CUID2 Scalar

* Prettier

---------

Co-authored-by: Arda TANRIKULU <ardatanrikulu@gmail.com>

Author: ifeanyi-ugwu

.changeset/cuddly-spoons-float.md

@@ -0,0 +1,5 @@
+---
+'graphql-scalars': minor
+---
+
+New CUID2 Scalar

.eslintrc.json

@@ -3,12 +3,7 @@
   "parserOptions": {
     "project": "./tsconfig.all.json"
   },
-  "extends": [
-    "eslint:recommended",
-    "standard",
-    "prettier",
-    "plugin:@typescript-eslint/recommended"
-  ],
+  "extends": ["eslint:recommended", "prettier", "plugin:@typescript-eslint/recommended"],
   "plugins": ["@typescript-eslint"],
   "rules": {
     "no-empty": "off",

package.json

@@ -71,7 +71,6 @@
     "cross-env": "10.1.0",
     "eslint": "9.37.0",
     "eslint-config-prettier": "10.1.8",
-    "eslint-config-standard": "17.1.0",
     "eslint-plugin-import": "2.32.0",
     "eslint-plugin-n": "17.23.1",
     "eslint-plugin-promise": "7.2.1",

src/index.ts

@@ -7,6 +7,7 @@ import {
   GraphQLCountryCode,
   GraphQLCountryName,
   GraphQLCuid,
+  GraphQLCuid2,
   GraphQLCurrency,
   GraphQLDate,
   GraphQLDateTime,
@@ -220,6 +221,7 @@ export const resolvers: Record<string, GraphQLScalarType> = {
   CountryCode: GraphQLCountryCode,
   CountryName: GraphQLCountryName,
   Cuid: GraphQLCuid,
+  Cuid2: GraphQLCuid2,
   Currency: GraphQLCurrency,
   Date: GraphQLDate,
   DateTime: GraphQLDateTime,
@@ -437,12 +439,15 @@ export {
 export { GeoJSON as GeoJSONTypeDefinition } from './typeDefs.js';
 export { CountryName as CountryNameTypeDefinition } from './typeDefs.js';
 export { ULID as ULIDTypeDefinition } from './typeDefs.js';
+export { Cuid2 as Cuid2TypeDefinition } from './typeDefs.js';
 export { GraphQLCountryName as CountryNameResolver };
 export { GraphQLCountryName };
 export { CountryName as CountryNameMock } from './mocks.js';
 export { GraphQLGeoJSON as GeoJSONResolver };
 export { GraphQLULID as ULIDResolver };
+export { GraphQLCuid2 as Cuid2Resolver };
 export { GraphQLGeoJSON };
 export { GraphQLULID };
 export { GeoJSON as GeoJSONMock } from './mocks.js';
+export { Cuid2 as Cuid2Mock } from './mocks.js';
 export { ULID as ULIDMock } from './mocks.js';

src/mocks.ts

@@ -1,4 +1,5 @@
 export const ULID = () => '01J9GHQM8N5X4TQ3M1ZV9J6CBK';
+export const Cuid2 = () => 'dp71y53f6eykvl5g1393rmhl';
 export const GeoJSON = () => 'Example GeoJSON';
 export const CountryName = () => 'Example CountryName';
 const BigIntMock = () => BigInt(Number.MAX_SAFE_INTEGER);

src/scalars/Cuid2.ts

@@ -0,0 +1,49 @@
+import { GraphQLScalarType, Kind, ValueNode } from 'graphql';
+import { createGraphQLError } from '../error.js';
+
+const CUID2_REGEX = /^[a-z][a-z0-9]{1,31}$/;
+
+const validateCuid2 = (value: any, ast?: ValueNode) => {
+  if (typeof value !== 'string') {
+    throw createGraphQLError(`Value is not string: ${value}`, ast ? { nodes: ast } : undefined);
+  }
+
+  if (!CUID2_REGEX.test(value)) {
+    throw createGraphQLError(
+      `Value is not a valid cuid2: ${value}`,
+      ast ? { nodes: ast } : undefined,
+    );
+  }
+
+  return value;
+};
+
+const specifiedByURL = 'https://github.com/paralleldrive/cuid2';
+
+export const GraphQLCuid2 = /*#__PURE__*/ new GraphQLScalarType({
+  name: 'Cuid2',
+  description: `A field whose value conforms to the cuid2 format, as specified in ${specifiedByURL}`,
+
+  serialize: validateCuid2,
+  parseValue: validateCuid2,
+
+  parseLiteral(ast) {
+    if (ast.kind !== Kind.STRING) {
+      throw createGraphQLError(`Can only validate strings as cuid2 but got: ${ast.kind}`, {
+        nodes: [ast],
+      });
+    }
+
+    return validateCuid2(ast.value, ast);
+  },
+
+  specifiedByURL,
+  extensions: {
+    codegenScalarType: 'string',
+    jsonSchema: {
+      title: 'Cuid2',
+      type: 'string',
+      pattern: CUID2_REGEX.source,
+    },
+  },
+});

src/scalars/index.ts

@@ -68,3 +68,4 @@ export { GraphQLDeweyDecimal } from './library/DeweyDecimal.js';
 export { GraphQLLCCSubclass } from './library/LCCSubclass.js';
 export { GraphQLIPCPatent } from './patent/IPCPatent.js';
 export { GraphQLULID } from './ULID.js';
+export { GraphQLCuid2 } from './Cuid2.js';

src/typeDefs.ts

@@ -1,4 +1,5 @@
 export const ULID = 'scalar ULID';
+export const Cuid2 = 'scalar Cuid2';
 export const GeoJSON = 'scalar GeoJSON';
 export const CountryName = 'scalar CountryName';
 export const BigInt = 'scalar BigInt';
@@ -80,6 +81,7 @@ export const typeDefs = [
   CountryCode,
   CountryName,
   Cuid,
+  Cuid2,
   Currency,
   Date,
   DateTime,

tests/Cuid2.test.ts

@@ -0,0 +1,104 @@
+/* global describe, test, expect */
+
+import { Kind } from 'graphql/language';
+import { GraphQLCuid2 } from '../src/scalars/Cuid2.js';
+
+describe('Cuid2', () => {
+  describe('valid', () => {
+    const validCuid2 = 'dp71y53f6eykvl5g1393rmhl';
+
+    test('serialize', () => {
+      expect(GraphQLCuid2.serialize(validCuid2)).toBe(validCuid2);
+    });
+
+    test('parseValue', () => {
+      expect(GraphQLCuid2.parseValue(validCuid2)).toBe(validCuid2);
+    });
+
+    test('parseLiteral', () => {
+      expect(
+        GraphQLCuid2.parseLiteral(
+          {
+            value: validCuid2,
+            kind: Kind.STRING,
+          },
+          {},
+        ),
+      ).toBe(validCuid2);
+    });
+  });
+
+  describe('invalid', () => {
+    describe('not a cuid2', () => {
+      test('serialize', () => {
+        expect(() => GraphQLCuid2.serialize('not-a-valid-cuid2')).toThrow(
+          /Value is not a valid cuid2/,
+        );
+      });
+
+      test('parseValue', () => {
+        expect(() => GraphQLCuid2.parseValue('not-a-valid-cuid2')).toThrow(
+          /Value is not a valid cuid2/,
+        );
+      });
+
+      test('parseLiteral', () => {
+        expect(() =>
+          GraphQLCuid2.parseLiteral(
+            {
+              value: 'not-a-valid-cuid2',
+              kind: Kind.STRING,
+            },
+            {},
+          ),
+        ).toThrow(/Value is not a valid cuid2/);
+      });
+    });
+
+    describe('not a string', () => {
+      test('serialize', () => {
+        expect(() => GraphQLCuid2.serialize(123)).toThrow(/Value is not string/);
+      });
+
+      test('parseValue', () => {
+        expect(() => GraphQLCuid2.parseValue(123)).toThrow(/Value is not string/);
+      });
+
+      test('parseLiteral', () => {
+        expect(() => GraphQLCuid2.parseLiteral({ value: '123', kind: Kind.INT }, {})).toThrow(
+          /Can only validate strings as cuid2 but got/,
+        );
+      });
+    });
+
+    describe('boundary cases', () => {
+      test('minimum length (2 characters)', () => {
+        const minCuid2 = 'a1';
+        expect(GraphQLCuid2.serialize(minCuid2)).toBe(minCuid2);
+        expect(GraphQLCuid2.parseValue(minCuid2)).toBe(minCuid2);
+        expect(GraphQLCuid2.parseLiteral({ value: minCuid2, kind: Kind.STRING }, {})).toBe(
+          minCuid2,
+        );
+      });
+
+      test('maximum length (32 characters)', () => {
+        const maxCuid2 = 'a123456789abcdef123456789abcdef1'; // starts with a letter
+        expect(GraphQLCuid2.serialize(maxCuid2)).toBe(maxCuid2);
+        expect(GraphQLCuid2.parseValue(maxCuid2)).toBe(maxCuid2);
+        expect(GraphQLCuid2.parseLiteral({ value: maxCuid2, kind: Kind.STRING }, {})).toBe(
+          maxCuid2,
+        );
+      });
+
+      test('too short (1 character)', () => {
+        const tooShort = 'a';
+        expect(() => GraphQLCuid2.serialize(tooShort)).toThrow(/Value is not a valid cuid2/);
+      });
+
+      test('too long (33 characters)', () => {
+        const tooLong = 'a1234567890abcdef1234567890abcdef1';
+        expect(() => GraphQLCuid2.serialize(tooLong)).toThrow(/Value is not a valid cuid2/);
+      });
+    });
+  });
+});

website/package.json

@@ -23,9 +23,9 @@
     "@types/react": "19.2.2",
     "cross-env": "10.1.0",
     "next-sitemap": "4.2.3",
+    "pagefind": "1.4.0",
     "postcss-import": "16.1.1",
     "postcss-lightningcss": "1.0.2",
-    "pagefind": "1.4.0",
     "tailwindcss": "3.4.18",
     "typescript": "5.9.3"
   },