Add support for generation of scalar fields

packages/core-generators/package.json

@@ -35,6 +35,18 @@
     "./extractors": {
       "types": "./dist/renderers/extractors.d.ts",
       "default": "./dist/renderers/extractors.js"
+    },
+    "./test-helpers": {
+      "types": "./dist/test-helpers/index.d.ts",
+      "default": "./dist/test-helpers/index.js"
+    },
+    "./test-helpers/setup": {
+      "types": "./dist/test-helpers/setup.d.ts",
+      "default": "./dist/test-helpers/setup.js"
+    },
+    "./test-helpers/vitest-types": {
+      "types": "./dist/test-helpers/vitest-types.d.ts",
+      "default": "./dist/test-helpers/vitest-types.js"
     }
   },
   "main": "dist/index.js",

packages/core-generators/src/test-helpers/import-map-helpers.ts

@@ -0,0 +1,42 @@
+import type {
+  InferTsImportMapFromSchema,
+  TsImportMapSchemaEntry,
+} from '../renderers/typescript/import-maps/types.js';
+
+import { createTsImportMap } from '../renderers/typescript/import-maps/ts-import-map.js';
+
+/**
+ * Creates a test import map with consistent module specifiers for testing
+ *
+ * Each import will use the pattern `<name>/<importKey>`, making it easy to
+ * identify which test module an import comes from
+ *
+ * @param importSchema - The import map schema to use
+ * @param name - Base name for the module (e.g., 'data-utils')
+ * @returns A mock import provider for testing
+ *
+ * @example
+ * ```typescript
+ * const schema = createTsImportMapSchema({
+ *   scalarField: {},
+ *   relationHelpers: {},
+ * });
+ *
+ * const imports = createTestTsImportMap(schema, 'data-utils');
+ * // Creates imports:
+ * //   scalarField -> 'data-utils/scalarField'
+ * //   relationHelpers -> 'data-utils/relationHelpers'
+ * ```
+ */
+export function createTestTsImportMap<
+  T extends Record<string, TsImportMapSchemaEntry>,
+>(importSchema: T, name: string): InferTsImportMapFromSchema<T> {
+  // Build the imports object based on the schema
+  const imports: Record<string, string> = {};
+
+  for (const key of Object.keys(importSchema)) {
+    imports[key] = `${name}/${key}`;
+  }
+
+  return createTsImportMap(importSchema, imports as Record<keyof T, string>);
+}

packages/core-generators/src/test-helpers/import-map-helpers.unit.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, it } from 'vitest';
+
+import { createTsImportMapSchema } from '../renderers/typescript/import-maps/ts-import-map.js';
+import { createTestTsImportMap } from './import-map-helpers.js';
+
+describe('createTestTsImportMap', () => {
+  it('creates import map with name-based module specifiers', () => {
+    const schema = createTsImportMapSchema({
+      scalarField: {},
+      relationHelpers: {},
+    });
+
+    const importMap = createTestTsImportMap(schema, 'data-utils');
+
+    // Check that the import map has the expected keys
+    expect(importMap).toHaveProperty('scalarField');
+    expect(importMap).toHaveProperty('relationHelpers');
+
+    // Check that imports use name-based module specifiers
+    expect(importMap.scalarField.moduleSpecifier).toBe(
+      'data-utils/scalarField',
+    );
+    expect(importMap.relationHelpers.moduleSpecifier).toBe(
+      'data-utils/relationHelpers',
+    );
+  });
+
+  it('creates consistent module specifiers for all keys', () => {
+    const schema = createTsImportMapSchema({
+      scalarField: {},
+      relationHelpers: {},
+      $Enums: {},
+    });
+
+    const importMap = createTestTsImportMap(schema, 'test-module');
+
+    expect(importMap.scalarField.moduleSpecifier).toBe(
+      'test-module/scalarField',
+    );
+    expect(importMap.$Enums.moduleSpecifier).toBe('test-module/$Enums');
+    expect(importMap.relationHelpers.moduleSpecifier).toBe(
+      'test-module/relationHelpers',
+    );
+  });
+
+  it('creates fragments that can be used in code generation', () => {
+    const schema = createTsImportMapSchema({
+      scalarField: {},
+    });
+
+    const importMap = createTestTsImportMap(schema, 'data-utils');
+
+    const fragment = importMap.scalarField.fragment();
+
+    expect(fragment.contents).toBe('scalarField');
+    expect(fragment.imports).toHaveLength(1);
+    expect(fragment.imports?.[0].moduleSpecifier).toBe(
+      'data-utils/scalarField',
+    );
+    expect(fragment.imports?.[0].namedImports).toEqual([
+      { name: 'scalarField' },
+    ]);
+  });
+
+  it('handles type-only imports correctly', () => {
+    const schema = createTsImportMapSchema({
+      MyType: { isTypeOnly: true },
+    });
+
+    const importMap = createTestTsImportMap(schema, 'types');
+
+    const fragment = importMap.MyType.typeFragment();
+
+    expect(fragment.imports).toHaveLength(1);
+    expect(fragment.imports?.[0].isTypeOnly).toBe(true);
+    expect(fragment.imports?.[0].moduleSpecifier).toBe('types/MyType');
+  });
+
+  it('handles wildcard exports', () => {
+    const schema = createTsImportMapSchema({
+      '*': {},
+    });
+
+    const importMap = createTestTsImportMap(schema, 'wildcard-module');
+
+    expect(importMap['*'].moduleSpecifier).toBe('wildcard-module/*');
+  });
+
+  it('handles exported aliases', () => {
+    const schema = createTsImportMapSchema({
+      defaultExport: { exportedAs: 'default' },
+    });
+
+    const importMap = createTestTsImportMap(schema, 'my-module');
+
+    const declaration = importMap.defaultExport.declaration();
+
+    expect(declaration.defaultImport).toBe('defaultExport');
+    expect(declaration.moduleSpecifier).toBe('my-module/defaultExport');
+  });
+});

packages/core-generators/src/test-helpers/index.ts

@@ -0,0 +1,43 @@
+/**
+ * Test helpers for @baseplate-dev/core-generators
+ *
+ * This module provides utilities for testing code generators, including:
+ * - Custom Vitest matchers for TypeScript fragments
+ * - Utilities for creating mock import providers
+ * - Fragment comparison functions
+ *
+ * @example
+ * ```typescript
+ * import { createTestTsImportMap, extendFragmentMatchers } from '@baseplate-dev/core-generators/test-helpers';
+ *
+ * // Extend Vitest matchers (call once in setup)
+ * extendFragmentMatchers();
+ *
+ * // Create mock import providers for testing
+ * const imports = createTestTsImportMap(schema);
+ *
+ * // Use custom matchers in tests
+ * expect(fragment).toMatchTsFragment(expectedFragment);
+ * expect(fragment).toIncludeImport('z', 'zod');
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+// Export import map helpers
+export { createTestTsImportMap } from './import-map-helpers.js';
+
+// Export matcher functions and types
+export {
+  extendFragmentMatchers,
+  fragmentMatchers,
+  type ToIncludeImportOptions,
+  type ToMatchTsFragmentOptions,
+} from './matchers.js';
+
+// Export utility functions
+export {
+  areFragmentsEqual,
+  type CompareFragmentsOptions,
+  normalizeFragment,
+} from './utils.js';