Add top-level domain as default for all links

- Add optional top-level 'domain' field in YAML config
- Links inherit from top-level domain unless they specify their own
- Update validation to require domain either at top-level or per-link
- Add tests for new domain inheritance behavior
- Update README with new schema documentation

Author: gugu

README.md

@@ -21,23 +21,23 @@ A GitHub Action that syncs short links from a `shortio.yaml` file in your reposi
 
 ```yaml
 # shortio.yaml
+domain: "short.example.com"  # Default domain for all links
+
 links:
   docs:
     url: "https://documentation.example.com/v2"
-    domain: "short.example.com"
     title: "Documentation"
     tags:
       - docs
       - public
 
   api:
     url: "https://api.example.com"
-    domain: "short.example.com"
     title: "API Reference"
 
   blog:
     url: "https://blog.example.com"
-    domain: "links.company.io"
+    domain: "links.company.io"  # Override default domain
     title: "Company Blog"
 ```
 
@@ -84,16 +84,25 @@ jobs:
 
 ### YAML Schema
 
-The `links` field is a map where each key is the slug (short path) and the value contains:
+**Top-level fields:**
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `domain` | string | No | Default domain for all links |
+| `links` | map | Yes | Map of slug → link configuration |
+
+**Link fields** (within `links` map):
 
 | Field | Type | Required | Description |
 |-------|------|----------|-------------|
 | *(key)* | string | Yes | The slug/short path (e.g., `docs` → short.example.com/docs) |
 | `url` | string | Yes | Destination URL |
-| `domain` | string | Yes | Short.io domain to use |
+| `domain` | string | No* | Short.io domain (required if no top-level `domain`) |
 | `title` | string | No | Link title for organization |
 | `tags` | string[] | No | Tags for categorization |
 
+*Each link must have a domain, either from the top-level `domain` or its own `domain` field.
+
 ## Examples
 
 ### Dry-run mode

src/config.test.ts

@@ -86,14 +86,69 @@ links:
     expect(() => parseConfig(TEST_FILE)).toThrow('Link "my-link" must have a non-empty "url" string');
   });
 
-  it('throws ConfigError for missing domain', () => {
+  it('throws ConfigError for missing domain when no top-level domain', () => {
     writeTestConfig(`
 links:
   my-link:
     url: https://example.com
 `);
     expect(() => parseConfig(TEST_FILE)).toThrow(ConfigError);
-    expect(() => parseConfig(TEST_FILE)).toThrow('Link "my-link" must have a non-empty "domain" string');
+    expect(() => parseConfig(TEST_FILE)).toThrow('Link "my-link" must have a "domain" (or set top-level "domain")');
+  });
+
+  it('parses config with top-level domain', () => {
+    writeTestConfig(`
+domain: short.io
+links:
+  my-link:
+    url: https://example.com
+  another-link:
+    url: https://test.com
+    title: Test Link
+`);
+    const config = parseConfig(TEST_FILE);
+    expect(config.domain).toBe('short.io');
+    expect(Object.keys(config.links)).toHaveLength(2);
+    expect(config.links['my-link'].domain).toBeUndefined();
+    expect(config.links['another-link'].domain).toBeUndefined();
+  });
+
+  it('allows per-link domain to override top-level domain', () => {
+    writeTestConfig(`
+domain: default.io
+links:
+  my-link:
+    url: https://example.com
+  override-link:
+    url: https://test.com
+    domain: custom.io
+`);
+    const config = parseConfig(TEST_FILE);
+    expect(config.domain).toBe('default.io');
+    expect(config.links['my-link'].domain).toBeUndefined();
+    expect(config.links['override-link'].domain).toBe('custom.io');
+  });
+
+  it('throws ConfigError for empty top-level domain', () => {
+    writeTestConfig(`
+domain: ""
+links:
+  my-link:
+    url: https://example.com
+`);
+    expect(() => parseConfig(TEST_FILE)).toThrow(ConfigError);
+    expect(() => parseConfig(TEST_FILE)).toThrow('Top-level "domain" must be a non-empty string');
+  });
+
+  it('throws ConfigError for non-string top-level domain', () => {
+    writeTestConfig(`
+domain: 123
+links:
+  my-link:
+    url: https://example.com
+`);
+    expect(() => parseConfig(TEST_FILE)).toThrow(ConfigError);
+    expect(() => parseConfig(TEST_FILE)).toThrow('Top-level "domain" must be a non-empty string');
   });
 
   it('throws ConfigError for invalid URL', () => {
@@ -180,4 +235,31 @@ describe('getUniqueDomains', () => {
     const domains = getUniqueDomains(config);
     expect(domains).toEqual([]);
   });
+
+  it('uses top-level domain when link domain is not specified', () => {
+    const config = {
+      domain: 'default.io',
+      links: {
+        'link1': { url: 'https://example.com' },
+        'link2': { url: 'https://test.com', domain: 'custom.io' },
+      },
+    };
+    const domains = getUniqueDomains(config);
+    expect(domains).toHaveLength(2);
+    expect(domains).toContain('default.io');
+    expect(domains).toContain('custom.io');
+  });
+
+  it('returns only top-level domain when all links use it', () => {
+    const config = {
+      domain: 'default.io',
+      links: {
+        'link1': { url: 'https://example.com' },
+        'link2': { url: 'https://test.com' },
+      },
+    };
+    const domains = getUniqueDomains(config);
+    expect(domains).toHaveLength(1);
+    expect(domains).toContain('default.io');
+  });
 });

src/config.ts

@@ -30,6 +30,11 @@ function validateConfig(config: unknown): asserts config is YamlConfig {
 
   const obj = config as Record<string, unknown>;
 
+  const defaultDomain = obj.domain;
+  if (defaultDomain !== undefined && (typeof defaultDomain !== 'string' || defaultDomain.trim() === '')) {
+    throw new ConfigError('Top-level "domain" must be a non-empty string');
+  }
+
   if (!obj.links || typeof obj.links !== 'object' || Array.isArray(obj.links)) {
     throw new ConfigError('Config must have a "links" map (use slug as key)');
   }
@@ -41,18 +46,19 @@ function validateConfig(config: unknown): asserts config is YamlConfig {
     if (!slug || slug.trim() === '') {
       throw new ConfigError('Link slug (key) must be a non-empty string');
     }
-    validateLink(link, slug);
+    validateLink(link, slug, defaultDomain as string | undefined);
 
     const validatedLink = link as YamlLinkValue;
-    const key = `${validatedLink.domain}/${slug}`;
+    const domain = validatedLink.domain ?? defaultDomain;
+    const key = `${domain}/${slug}`;
     if (seen.has(key)) {
       throw new ConfigError(`Duplicate link: ${key}`);
     }
     seen.add(key);
   }
 }
 
-function validateLink(link: unknown, slug: string): asserts link is YamlLinkValue {
+function validateLink(link: unknown, slug: string, defaultDomain?: string): asserts link is YamlLinkValue {
   if (!link || typeof link !== 'object') {
     throw new ConfigError(`Link "${slug}" must be an object`);
   }
@@ -63,8 +69,12 @@ function validateLink(link: unknown, slug: string): asserts link is YamlLinkValu
     throw new ConfigError(`Link "${slug}" must have a non-empty "url" string`);
   }
 
-  if (typeof obj.domain !== 'string' || obj.domain.trim() === '') {
-    throw new ConfigError(`Link "${slug}" must have a non-empty "domain" string`);
+  if (obj.domain !== undefined) {
+    if (typeof obj.domain !== 'string' || obj.domain.trim() === '') {
+      throw new ConfigError(`Link "${slug}" "domain" must be a non-empty string`);
+    }
+  } else if (!defaultDomain) {
+    throw new ConfigError(`Link "${slug}" must have a "domain" (or set top-level "domain")`);
   }
 
   try {
@@ -91,7 +101,7 @@ function validateLink(link: unknown, slug: string): asserts link is YamlLinkValu
 
 export function getUniqueDomains(config: YamlConfig): string[] {
   const domains = new Set<string>();
-  for (const link of Object.values(config.links)) {
+  for (const link of getLinksArray(config)) {
     domains.add(link.domain);
   }
   return Array.from(domains);

src/types.test.ts

@@ -30,12 +30,15 @@ describe('getLinksArray', () => {
       slug: 'link-a',
       url: 'https://a.com',
       domain: 'short.io',
+      title: undefined,
+      tags: undefined,
     });
     expect(links).toContainEqual({
       slug: 'link-b',
       url: 'https://b.com',
       domain: 'short.io',
       title: 'Link B',
+      tags: undefined,
     });
   });
 
@@ -58,4 +61,34 @@ describe('getLinksArray', () => {
     const links = getLinksArray(config);
     expect(links[0].tags).toEqual(['tag1', 'tag2']);
   });
+
+  it('applies top-level domain when link domain is not specified', () => {
+    const config: YamlConfig = {
+      domain: 'default.io',
+      links: {
+        'link-a': { url: 'https://a.com' },
+        'link-b': { url: 'https://b.com' },
+      },
+    };
+    const links = getLinksArray(config);
+    expect(links).toHaveLength(2);
+    expect(links[0].domain).toBe('default.io');
+    expect(links[1].domain).toBe('default.io');
+  });
+
+  it('allows per-link domain to override top-level domain', () => {
+    const config: YamlConfig = {
+      domain: 'default.io',
+      links: {
+        'link-a': { url: 'https://a.com' },
+        'link-b': { url: 'https://b.com', domain: 'custom.io' },
+      },
+    };
+    const links = getLinksArray(config);
+    expect(links).toHaveLength(2);
+    const linkA = links.find(l => l.slug === 'link-a');
+    const linkB = links.find(l => l.slug === 'link-b');
+    expect(linkA?.domain).toBe('default.io');
+    expect(linkB?.domain).toBe('custom.io');
+  });
 });

src/types.ts

@@ -1,15 +1,20 @@
 export interface YamlLinkValue {
   url: string;
-  domain: string;
+  domain?: string;
   title?: string;
   tags?: string[];
 }
 
-export interface YamlLink extends YamlLinkValue {
+export interface YamlLink {
   slug: string;
+  url: string;
+  domain: string;
+  title?: string;
+  tags?: string[];
 }
 
 export interface YamlConfig {
+  domain?: string;
   links: Record<string, YamlLinkValue>;
 }
 
@@ -65,6 +70,9 @@ export function getLinkKey(domain: string, slug: string): LinkKey {
 export function getLinksArray(config: YamlConfig): YamlLink[] {
   return Object.entries(config.links).map(([slug, value]) => ({
     slug,
-    ...value,
+    url: value.url,
+    domain: value.domain ?? config.domain!,
+    title: value.title,
+    tags: value.tags,
   }));
 }