nebula-cms 0.1.0

package/tests/client/js/utils/file-types.test.ts

@@ -0,0 +1,268 @@
+import { describe, it, expect } from 'vitest';
+import {
+  getExtensionsForSchema,
+  hasBodyEditor,
+  getFileCategory,
+  getDataFormat,
+  stripExtension,
+  getDefaultExtension,
+} from '../../../../src/client/js/utils/file-types';
+
+//////////////////////////////
+// getExtensionsForSchema
+//////////////////////////////
+
+describe('getExtensionsForSchema', () => {
+  it('returns all extensions for a single type identifier', () => {
+    expect(getExtensionsForSchema({ files: ['md'] })).toEqual([
+      '.md',
+      '.markdown',
+    ]);
+  });
+
+  it('returns extensions for multiple type identifiers combined', () => {
+    expect(getExtensionsForSchema({ files: ['md', 'json'] })).toEqual([
+      '.md',
+      '.markdown',
+      '.json',
+    ]);
+  });
+
+  it('returns extensions for all frontmatter types', () => {
+    expect(getExtensionsForSchema({ files: ['md', 'mdx', 'markdoc'] })).toEqual(
+      ['.md', '.markdown', '.mdx', '.mdoc', '.markdoc'],
+    );
+  });
+
+  it('returns extensions for all data types', () => {
+    expect(getExtensionsForSchema({ files: ['json', 'yaml', 'toml'] })).toEqual(
+      ['.json', '.yml', '.yaml', '.toml'],
+    );
+  });
+
+  it('returns an empty array when files is empty', () => {
+    expect(getExtensionsForSchema({ files: [] })).toEqual([]);
+  });
+
+  it('skips unknown type identifiers without throwing', () => {
+    expect(getExtensionsForSchema({ files: ['md', 'unknown-type'] })).toEqual([
+      '.md',
+      '.markdown',
+    ]);
+  });
+
+  it('returns an empty array when files property is missing', () => {
+    expect(getExtensionsForSchema({})).toEqual([]);
+  });
+});
+
+//////////////////////////////
+// hasBodyEditor
+//////////////////////////////
+
+describe('hasBodyEditor', () => {
+  it('returns true for .md files', () => {
+    expect(hasBodyEditor('post.md')).toBe(true);
+  });
+
+  it('returns true for .markdown files', () => {
+    expect(hasBodyEditor('post.markdown')).toBe(true);
+  });
+
+  it('returns true for .mdx files', () => {
+    expect(hasBodyEditor('component.mdx')).toBe(true);
+  });
+
+  it('returns true for .mdoc files', () => {
+    expect(hasBodyEditor('doc.mdoc')).toBe(true);
+  });
+
+  it('returns true for .markdoc files', () => {
+    expect(hasBodyEditor('doc.markdoc')).toBe(true);
+  });
+
+  it('returns false for .json files', () => {
+    expect(hasBodyEditor('data.json')).toBe(false);
+  });
+
+  it('returns false for .yml files', () => {
+    expect(hasBodyEditor('config.yml')).toBe(false);
+  });
+
+  it('returns false for .yaml files', () => {
+    expect(hasBodyEditor('config.yaml')).toBe(false);
+  });
+
+  it('returns false for .toml files', () => {
+    expect(hasBodyEditor('config.toml')).toBe(false);
+  });
+
+  it('returns false for unrecognised extensions', () => {
+    expect(hasBodyEditor('file.txt')).toBe(false);
+  });
+});
+
+//////////////////////////////
+// getFileCategory
+//////////////////////////////
+
+describe('getFileCategory', () => {
+  it('returns frontmatter for .md files', () => {
+    expect(getFileCategory('post.md')).toBe('frontmatter');
+  });
+
+  it('returns frontmatter for .markdown files', () => {
+    expect(getFileCategory('post.markdown')).toBe('frontmatter');
+  });
+
+  it('returns frontmatter for .mdx files', () => {
+    expect(getFileCategory('component.mdx')).toBe('frontmatter');
+  });
+
+  it('returns frontmatter for .mdoc files', () => {
+    expect(getFileCategory('doc.mdoc')).toBe('frontmatter');
+  });
+
+  it('returns frontmatter for .markdoc files', () => {
+    expect(getFileCategory('doc.markdoc')).toBe('frontmatter');
+  });
+
+  it('returns data for .json files', () => {
+    expect(getFileCategory('data.json')).toBe('data');
+  });
+
+  it('returns data for .yml files', () => {
+    expect(getFileCategory('config.yml')).toBe('data');
+  });
+
+  it('returns data for .yaml files', () => {
+    expect(getFileCategory('config.yaml')).toBe('data');
+  });
+
+  it('returns data for .toml files', () => {
+    expect(getFileCategory('config.toml')).toBe('data');
+  });
+
+  it('returns null for unrecognised extensions', () => {
+    expect(getFileCategory('file.txt')).toBe(null);
+  });
+});
+
+//////////////////////////////
+// getDataFormat
+//////////////////////////////
+
+describe('getDataFormat', () => {
+  it('returns json for .json files', () => {
+    expect(getDataFormat('data.json')).toBe('json');
+  });
+
+  it('returns yaml for .yml files', () => {
+    expect(getDataFormat('config.yml')).toBe('yaml');
+  });
+
+  it('returns yaml for .yaml files', () => {
+    expect(getDataFormat('config.yaml')).toBe('yaml');
+  });
+
+  it('returns toml for .toml files', () => {
+    expect(getDataFormat('config.toml')).toBe('toml');
+  });
+
+  it('returns null for frontmatter files', () => {
+    expect(getDataFormat('post.md')).toBe(null);
+  });
+
+  it('returns null for .mdx files', () => {
+    expect(getDataFormat('component.mdx')).toBe(null);
+  });
+
+  it('returns null for unrecognised extensions', () => {
+    expect(getDataFormat('file.txt')).toBe(null);
+  });
+});
+
+//////////////////////////////
+// stripExtension
+//////////////////////////////
+
+describe('stripExtension', () => {
+  it('strips .md extension', () => {
+    expect(stripExtension('my-post.md')).toBe('my-post');
+  });
+
+  it('strips .markdown extension', () => {
+    expect(stripExtension('my-post.markdown')).toBe('my-post');
+  });
+
+  it('strips .mdx extension', () => {
+    expect(stripExtension('component.mdx')).toBe('component');
+  });
+
+  it('strips .mdoc extension', () => {
+    expect(stripExtension('doc.mdoc')).toBe('doc');
+  });
+
+  it('strips .markdoc extension', () => {
+    expect(stripExtension('doc.markdoc')).toBe('doc');
+  });
+
+  it('strips .json extension', () => {
+    expect(stripExtension('data.json')).toBe('data');
+  });
+
+  it('strips .yml extension', () => {
+    expect(stripExtension('config.yml')).toBe('config');
+  });
+
+  it('strips .yaml extension', () => {
+    expect(stripExtension('config.yaml')).toBe('config');
+  });
+
+  it('strips .toml extension', () => {
+    expect(stripExtension('config.toml')).toBe('config');
+  });
+
+  it('returns filename unchanged for unrecognised extensions', () => {
+    expect(stripExtension('file.txt')).toBe('file.txt');
+  });
+
+  it('only strips the last known extension in a double-extension filename', () => {
+    // Filenames with multiple dots: strip only the recognised trailing extension
+    expect(stripExtension('my.post.md')).toBe('my.post');
+  });
+});
+
+//////////////////////////////
+// getDefaultExtension
+//////////////////////////////
+
+describe('getDefaultExtension', () => {
+  it('returns .md as the default extension for md', () => {
+    expect(getDefaultExtension('md')).toBe('.md');
+  });
+
+  it('returns .mdx as the default extension for mdx', () => {
+    expect(getDefaultExtension('mdx')).toBe('.mdx');
+  });
+
+  it('returns .mdoc as the default extension for markdoc', () => {
+    expect(getDefaultExtension('markdoc')).toBe('.mdoc');
+  });
+
+  it('returns .json as the default extension for json', () => {
+    expect(getDefaultExtension('json')).toBe('.json');
+  });
+
+  it('returns .yml as the default extension for yaml', () => {
+    expect(getDefaultExtension('yaml')).toBe('.yml');
+  });
+
+  it('returns .toml as the default extension for toml', () => {
+    expect(getDefaultExtension('toml')).toBe('.toml');
+  });
+
+  it('returns null for unknown type identifiers', () => {
+    expect(getDefaultExtension('unknown')).toBe(null);
+  });
+});

package/tests/client/js/utils/frontmatter.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect } from 'vitest';
+import { splitFrontmatter } from '../../../../src/client/js/utils/frontmatter';
+
+describe('splitFrontmatter', () => {
+  it('splits valid YAML frontmatter and body', () => {
+    const content = '---\ntitle: Hello\n---\nBody text here.';
+    const result = splitFrontmatter(content);
+    // slice(4, closeIndex) stops before the \n that precedes ---
+    expect(result.rawFrontmatter).toBe('title: Hello');
+    expect(result.body).toBe('Body text here.');
+  });
+
+  it('returns an empty body when there is only frontmatter', () => {
+    const content = '---\ntitle: No Body\n---\n';
+    const result = splitFrontmatter(content);
+    expect(result.rawFrontmatter).toBe('title: No Body');
+    expect(result.body).toBe('');
+  });
+
+  it('handles frontmatter with no trailing newline (ends with ---)', () => {
+    // endsWith('\n---') branch: slice(4, length - 4) trims the leading newline of the delimiter
+    const content = '---\ntitle: EOF\n---';
+    const result = splitFrontmatter(content);
+    expect(result.rawFrontmatter).toBe('title: EOF');
+    expect(result.body).toBe('');
+  });
+
+  it('returns empty frontmatter and full content when no frontmatter delimiter is present', () => {
+    const content = 'Just plain body text.';
+    const result = splitFrontmatter(content);
+    expect(result.rawFrontmatter).toBe('');
+    expect(result.body).toBe('Just plain body text.');
+  });
+
+  it('returns empty frontmatter and full content for an empty string', () => {
+    const result = splitFrontmatter('');
+    expect(result.rawFrontmatter).toBe('');
+    expect(result.body).toBe('');
+  });
+
+  it('rejects a horizontal rule (----) at the start — not treated as frontmatter', () => {
+    const content = '----\ntitle: Nope\n---\nBody.';
+    const result = splitFrontmatter(content);
+    expect(result.rawFrontmatter).toBe('');
+    expect(result.body).toBe(content);
+  });
+
+  it('strips a leading BOM character before processing', () => {
+    const content = '\uFEFF---\ntitle: BOM\n---\nBody.';
+    const result = splitFrontmatter(content);
+    expect(result.rawFrontmatter).toBe('title: BOM');
+    expect(result.body).toBe('Body.');
+  });
+
+  it('normalises CRLF line endings before processing', () => {
+    const content = '---\r\ntitle: CRLF\r\n---\r\nBody.';
+    const result = splitFrontmatter(content);
+    expect(result.rawFrontmatter).toBe('title: CRLF');
+    expect(result.body).toBe('Body.');
+  });
+
+  it('returns empty frontmatter when the closing delimiter is missing', () => {
+    // No closing --- so the entire content is treated as body
+    const content = '---\ntitle: Unclosed';
+    const result = splitFrontmatter(content);
+    expect(result.rawFrontmatter).toBe('');
+    expect(result.body).toBe(content);
+  });
+
+  it('treats content starting with --- but missing a newline as a non-match', () => {
+    // "---" without an immediate newline is not a valid opening delimiter
+    const content = '--- title: Inline';
+    const result = splitFrontmatter(content);
+    expect(result.rawFrontmatter).toBe('');
+    expect(result.body).toBe(content);
+  });
+
+  it('handles multiline frontmatter with body correctly', () => {
+    const content =
+      '---\ntitle: Multi\nauthor: Jane\ntags:\n  - a\n  - b\n---\n# Heading\n\nParagraph.';
+    const result = splitFrontmatter(content);
+    expect(result.rawFrontmatter).toBe(
+      'title: Multi\nauthor: Jane\ntags:\n  - a\n  - b',
+    );
+    expect(result.body).toBe('# Heading\n\nParagraph.');
+  });
+});

package/tests/client/js/utils/schema-utils.test.ts

@@ -0,0 +1,318 @@
+import { describe, it, expect } from 'vitest';
+import {
+  resolveFieldType,
+  createDefaultValue,
+  extractTabs,
+  getFieldsForTab,
+  getByPath,
+  setByPath,
+} from '../../../../src/client/js/utils/schema-utils';
+
+//////////////////////////////
+// resolveFieldType
+//////////////////////////////
+
+describe('resolveFieldType', () => {
+  it('resolves type: string to kind: string', () => {
+    expect(resolveFieldType({ type: 'string' })).toEqual({ kind: 'string' });
+  });
+
+  it('resolves type: number to kind: number', () => {
+    expect(resolveFieldType({ type: 'number' })).toEqual({ kind: 'number' });
+  });
+
+  it('resolves type: integer to kind: number', () => {
+    expect(resolveFieldType({ type: 'integer' })).toEqual({ kind: 'number' });
+  });
+
+  it('resolves type: boolean to kind: boolean', () => {
+    expect(resolveFieldType({ type: 'boolean' })).toEqual({ kind: 'boolean' });
+  });
+
+  it('resolves type: array to kind: array', () => {
+    expect(resolveFieldType({ type: 'array' })).toEqual({ kind: 'array' });
+  });
+
+  it('resolves type: object to kind: object', () => {
+    expect(resolveFieldType({ type: 'object' })).toEqual({ kind: 'object' });
+  });
+
+  it('resolves string with format: date-time to kind: date', () => {
+    expect(resolveFieldType({ type: 'string', format: 'date-time' })).toEqual({
+      kind: 'date',
+    });
+  });
+
+  it('resolves string with enum values to kind: enum with options', () => {
+    const result = resolveFieldType({ type: 'string', enum: ['a', 'b', 'c'] });
+    expect(result).toEqual({ kind: 'enum', options: ['a', 'b', 'c'] });
+  });
+
+  it('resolves unknown type to kind: unknown', () => {
+    expect(resolveFieldType({ type: 'bogus' })).toEqual({ kind: 'unknown' });
+  });
+
+  it('resolves schema with no type to kind: unknown', () => {
+    expect(resolveFieldType({})).toEqual({ kind: 'unknown' });
+  });
+
+  it('unwraps nullable anyOf and marks nullable: true', () => {
+    const schema = {
+      anyOf: [{ type: 'string' }, { type: 'null' }],
+    };
+    expect(resolveFieldType(schema)).toEqual({
+      kind: 'string',
+      nullable: true,
+    });
+  });
+
+  it('unwraps nullable anyOf for date-time and marks nullable: true', () => {
+    const schema = {
+      anyOf: [{ type: 'string', format: 'date-time' }, { type: 'null' }],
+    };
+    expect(resolveFieldType(schema)).toEqual({ kind: 'date', nullable: true });
+  });
+
+  it('date-time format takes precedence over enum when both present', () => {
+    // format is checked before enum in the implementation
+    const result = resolveFieldType({
+      type: 'string',
+      format: 'date-time',
+      enum: ['x'],
+    });
+    expect(result.kind).toBe('date');
+  });
+});
+
+//////////////////////////////
+// createDefaultValue
+//////////////////////////////
+
+describe('createDefaultValue', () => {
+  it('returns an explicit schema default when present', () => {
+    expect(createDefaultValue({ type: 'string', default: 'hello' })).toBe(
+      'hello',
+    );
+  });
+
+  it('returns an explicit default of false (falsy default honoured)', () => {
+    expect(createDefaultValue({ type: 'boolean', default: false })).toBe(false);
+  });
+
+  it('returns empty string for type: string', () => {
+    expect(createDefaultValue({ type: 'string' })).toBe('');
+  });
+
+  it('returns 0 for type: number', () => {
+    expect(createDefaultValue({ type: 'number' })).toBe(0);
+  });
+
+  it('returns 0 for type: integer', () => {
+    expect(createDefaultValue({ type: 'integer' })).toBe(0);
+  });
+
+  it('returns false for type: boolean', () => {
+    expect(createDefaultValue({ type: 'boolean' })).toBe(false);
+  });
+
+  it('returns [] for type: array', () => {
+    expect(createDefaultValue({ type: 'array' })).toEqual([]);
+  });
+
+  it('returns {} for type: object with no properties', () => {
+    expect(createDefaultValue({ type: 'object' })).toEqual({});
+  });
+
+  it('recursively builds defaults for object properties', () => {
+    const schema = {
+      type: 'object',
+      properties: {
+        name: { type: 'string' },
+        count: { type: 'number' },
+        active: { type: 'boolean' },
+      },
+    };
+    expect(createDefaultValue(schema)).toEqual({
+      name: '',
+      count: 0,
+      active: false,
+    });
+  });
+
+  it('returns null for a nullable anyOf schema', () => {
+    const schema = { anyOf: [{ type: 'string' }, { type: 'null' }] };
+    expect(createDefaultValue(schema)).toBeNull();
+  });
+
+  it('returns null for an unrecognised type', () => {
+    expect(createDefaultValue({ type: 'bogus' })).toBeNull();
+  });
+
+  it('returns null for an empty schema', () => {
+    expect(createDefaultValue({})).toBeNull();
+  });
+});
+
+//////////////////////////////
+// extractTabs
+//////////////////////////////
+
+describe('extractTabs', () => {
+  it('returns an empty array when the schema has no properties', () => {
+    expect(extractTabs({})).toEqual([]);
+  });
+
+  it('returns an empty array when no fields have a tab array', () => {
+    const schema = { properties: { title: { type: 'string' } } };
+    expect(extractTabs(schema)).toEqual([]);
+  });
+
+  it('returns sorted, deduplicated tab names', () => {
+    const schema = {
+      properties: {
+        title: { type: 'string', tab: ['Content'] },
+        slug: { type: 'string', tab: ['SEO', 'Content'] },
+        date: { type: 'string', tab: ['Metadata'] },
+      },
+    };
+    expect(extractTabs(schema)).toEqual(['Content', 'Metadata', 'SEO']);
+  });
+
+  it('deduplicates tab names appearing across multiple fields', () => {
+    const schema = {
+      properties: {
+        a: { tab: ['Shared'] },
+        b: { tab: ['Shared'] },
+      },
+    };
+    expect(extractTabs(schema)).toEqual(['Shared']);
+  });
+
+  it('ignores fields whose tab value is not an array', () => {
+    const schema = {
+      properties: {
+        a: { tab: 'not-an-array' },
+        b: { tab: ['Real'] },
+      },
+    };
+    expect(extractTabs(schema)).toEqual(['Real']);
+  });
+});
+
+//////////////////////////////
+// getFieldsForTab
+//////////////////////////////
+
+describe('getFieldsForTab', () => {
+  const schema = {
+    properties: {
+      title: { type: 'string', tab: ['Content'] },
+      slug: { type: 'string', tab: ['SEO'] },
+      date: { type: 'string', tab: ['Metadata', 'Content'] },
+      $schema: { type: 'string' },
+    },
+  };
+
+  it('returns all field names (excluding $schema) when tab is null', () => {
+    const result = getFieldsForTab(schema, null);
+    expect(result).toContain('title');
+    expect(result).toContain('slug');
+    expect(result).toContain('date');
+    expect(result).not.toContain('$schema');
+  });
+
+  it('returns only fields belonging to the given tab', () => {
+    expect(getFieldsForTab(schema, 'Content')).toEqual(['title', 'date']);
+  });
+
+  it('returns the correct subset for SEO tab', () => {
+    expect(getFieldsForTab(schema, 'SEO')).toEqual(['slug']);
+  });
+
+  it('returns an empty array for a tab with no matching fields', () => {
+    expect(getFieldsForTab(schema, 'NonExistent')).toEqual([]);
+  });
+
+  it('returns an empty array when the schema has no properties', () => {
+    expect(getFieldsForTab({}, 'Content')).toEqual([]);
+  });
+});
+
+//////////////////////////////
+// getByPath
+//////////////////////////////
+
+describe('getByPath', () => {
+  it('returns the root object for an empty path', () => {
+    const obj = { a: 1 };
+    expect(getByPath(obj, [])).toBe(obj);
+  });
+
+  it('reads a top-level property by key', () => {
+    expect(getByPath({ name: 'Alice' }, ['name'])).toBe('Alice');
+  });
+
+  it('traverses nested objects', () => {
+    const obj = { a: { b: { c: 42 } } };
+    expect(getByPath(obj, ['a', 'b', 'c'])).toBe(42);
+  });
+
+  it('reads array elements by numeric index', () => {
+    const obj = { items: ['x', 'y', 'z'] };
+    expect(getByPath(obj, ['items', 1])).toBe('y');
+  });
+
+  it('returns undefined when a segment is missing', () => {
+    expect(getByPath({ a: 1 }, ['b', 'c'])).toBeUndefined();
+  });
+
+  it('returns undefined when traversing through null', () => {
+    expect(getByPath({ a: null }, ['a', 'b'])).toBeUndefined();
+  });
+
+  it('returns undefined when traversing through undefined', () => {
+    expect(getByPath({ a: undefined }, ['a', 'b'])).toBeUndefined();
+  });
+});
+
+//////////////////////////////
+// setByPath
+//////////////////////////////
+
+describe('setByPath', () => {
+  it('sets a top-level property', () => {
+    const obj: Record<string, unknown> = {};
+    setByPath(obj, ['name'], 'Alice');
+    expect(obj['name']).toBe('Alice');
+  });
+
+  it('sets a deeply nested property, creating intermediates', () => {
+    const obj: Record<string, unknown> = {};
+    setByPath(obj, ['a', 'b', 'c'], 99);
+    expect((obj['a'] as Record<string, unknown>)['b']).toEqual({ c: 99 });
+  });
+
+  it('overwrites an existing value', () => {
+    const obj = { score: 1 };
+    setByPath(obj, ['score'], 100);
+    expect(obj['score']).toBe(100);
+  });
+
+  it('sets a value at a numeric array index', () => {
+    const obj: Record<string, unknown> = { items: ['a', 'b', 'c'] };
+    setByPath(obj, ['items', 1], 'X');
+    expect((obj['items'] as string[])[1]).toBe('X');
+  });
+
+  it('does nothing for an empty path', () => {
+    const obj = { a: 1 };
+    setByPath(obj, [], 'should-not-apply');
+    expect(obj).toEqual({ a: 1 });
+  });
+
+  it('creates missing intermediate objects', () => {
+    const obj: Record<string, unknown> = {};
+    setByPath(obj, ['x', 'y'], 'deep');
+    expect(obj).toEqual({ x: { y: 'deep' } });
+  });
+});