@jackwener/opencli 1.3.3 → 1.4.0

package/src/clis/pixiv/download.test.ts

@@ -0,0 +1,114 @@
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { CliCommand } from '../../registry.js';
+import { getRegistry } from '../../registry.js';
+import { AuthRequiredError, CommandExecutionError } from '../../errors.js';
+import { createPageMock } from './test-utils.js';
+
+// Mock download dependencies before importing the adapter
+const { mockHttpDownload, mockMkdirSync } = vi.hoisted(() => ({
+  mockHttpDownload: vi.fn(),
+  mockMkdirSync: vi.fn(),
+}));
+
+vi.mock('../../download/index.js', () => ({
+  formatCookieHeader: vi.fn().mockReturnValue('cookie=value'),
+  httpDownload: mockHttpDownload,
+}));
+
+vi.mock('node:fs', () => ({
+  mkdirSync: mockMkdirSync,
+}));
+
+// Now import the adapter (after mocks are set up)
+await import('./download.js');
+
+let cmd: CliCommand;
+
+beforeAll(() => {
+  cmd = getRegistry().get('pixiv/download')!;
+  expect(cmd?.func).toBeTypeOf('function');
+});
+
+describe('pixiv download', () => {
+  beforeEach(() => {
+    mockHttpDownload.mockReset();
+    mockMkdirSync.mockReset();
+  });
+
+  it('throws CommandExecutionError on invalid illust ID', async () => {
+    const page = createPageMock([]);
+
+    await expect(cmd.func!(page, { 'illust-id': 'abc', output: '/tmp/test' })).rejects.toThrow(CommandExecutionError);
+  });
+
+  it('throws AuthRequiredError on 403', async () => {
+    const page = createPageMock([{ __httpError: 403 }]);
+
+    await expect(cmd.func!(page, { 'illust-id': '12345', output: '/tmp/test' })).rejects.toThrow(AuthRequiredError);
+  });
+
+  it('throws CommandExecutionError on 404', async () => {
+    const page = createPageMock([{ __httpError: 404 }]);
+
+    await expect(cmd.func!(page, { 'illust-id': '12345', output: '/tmp/test' })).rejects.toThrow(CommandExecutionError);
+  });
+
+  it('throws CommandExecutionError on non-auth HTTP failure', async () => {
+    const page = createPageMock([{ __httpError: 500 }]);
+
+    await expect(cmd.func!(page, { 'illust-id': '12345', output: '/tmp/test' })).rejects.toThrow(CommandExecutionError);
+  });
+
+  it('returns failure when no images found', async () => {
+    const page = createPageMock([{ body: [] }]);
+
+    const result = (await cmd.func!(page, { 'illust-id': '12345', output: '/tmp/test' })) as any[];
+    expect(result).toEqual([{ index: 0, type: '-', status: 'failed', size: 'No images found' }]);
+  });
+
+  it('downloads images with Referer header', async () => {
+    mockHttpDownload.mockResolvedValue({ success: true, size: 1024000 });
+
+    const page = createPageMock([
+      {
+        body: [
+          { urls: { original: 'https://i.pximg.net/img-original/img/2025/01/01/00/00/00/12345_p0.png' } },
+          { urls: { original: 'https://i.pximg.net/img-original/img/2025/01/01/00/00/00/12345_p1.jpg' } },
+        ],
+      },
+    ]);
+
+    const result = (await cmd.func!(page, { 'illust-id': '12345', output: '/tmp/test' })) as any[];
+
+    expect(result).toHaveLength(2);
+    expect(result[0]).toMatchObject({ index: 1, type: 'image', status: 'success' });
+    expect(result[1]).toMatchObject({ index: 2, type: 'image', status: 'success' });
+
+    // Verify Referer header was passed
+    expect(mockHttpDownload).toHaveBeenCalledTimes(2);
+    const firstCallOpts = mockHttpDownload.mock.calls[0][2];
+    expect(firstCallOpts.headers).toEqual({ Referer: 'https://www.pixiv.net/' });
+  });
+
+  it('handles individual download failures gracefully', async () => {
+    mockHttpDownload
+      .mockResolvedValueOnce({ success: true, size: 512000 })
+      .mockRejectedValueOnce(new Error('Connection timeout'));
+
+    const page = createPageMock([
+      {
+        body: [
+          { urls: { original: 'https://i.pximg.net/img/12345_p0.png' } },
+          { urls: { original: 'https://i.pximg.net/img/12345_p1.png' } },
+        ],
+      },
+    ]);
+
+    const result = (await cmd.func!(page, { 'illust-id': '12345', output: '/tmp/test' })) as any[];
+
+    expect(result).toHaveLength(2);
+    expect(result[0].status).toBe('success');
+    expect(result[1].status).toBe('failed');
+    expect(result[1].size).toBe('Connection timeout');
+  });
+});

package/src/clis/pixiv/download.ts

@@ -0,0 +1,91 @@
+/**
+ * Pixiv download — download all images from an illustration.
+ *
+ * Pixiv's CDN (i.pximg.net) requires Referer: https://www.pixiv.net/ header.
+ * Uses the /ajax/illust/{id}/pages API to get original-quality image URLs.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { cli, Strategy } from '../../registry.js';
+import { formatCookieHeader, httpDownload } from '../../download/index.js';
+import { formatBytes } from '../../download/progress.js';
+import { CommandExecutionError, getErrorMessage } from '../../errors.js';
+import { pixivFetch } from './utils.js';
+
+cli({
+  site: 'pixiv',
+  name: 'download',
+  description: 'Download illustration images from Pixiv',
+  domain: 'www.pixiv.net',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'illust-id', positional: true, required: true, help: 'Illustration ID' },
+    { name: 'output', default: './pixiv-downloads', help: 'Output directory' },
+  ],
+  columns: ['index', 'type', 'status', 'size'],
+
+  func: async (page, kwargs) => {
+    const illustId = String(kwargs['illust-id'] ?? '');
+    const output = String(kwargs.output ?? './pixiv-downloads');
+
+    if (!/^\d+$/.test(illustId)) {
+      throw new CommandExecutionError(`Invalid illustration ID: ${illustId}`);
+    }
+
+    // pixivFetch handles navigate + error checking; returns the response body directly
+    const pages: any[] = await pixivFetch(page, `/ajax/illust/${illustId}/pages`, {
+      notFoundMsg: `Illustration not found: ${illustId}`,
+    }) || [];
+
+    if (pages.length === 0) {
+      return [{ index: 0, type: '-', status: 'failed', size: 'No images found' }];
+    }
+
+    // Extract cookies for authenticated downloads
+    const cookies = formatCookieHeader(await page.getCookies({ domain: 'pixiv.net' }));
+
+    // Create output directory
+    const outputDir = path.join(output, illustId);
+    fs.mkdirSync(outputDir, { recursive: true });
+
+    const results = [];
+
+    for (let i = 0; i < pages.length; i++) {
+      const p = pages[i];
+      const url = p.urls?.original || p.urls?.regular || '';
+      if (!url) {
+        results.push({ index: i + 1, type: 'image', status: 'failed', size: 'No URL' });
+        continue;
+      }
+
+      try {
+        const ext = path.extname(new URL(url).pathname) || '.jpg';
+        const filename = `${illustId}_p${i}${ext}`;
+        const destPath = path.join(outputDir, filename);
+
+        const result = await httpDownload(url, destPath, {
+          cookies,
+          headers: { Referer: 'https://www.pixiv.net/' },
+          timeout: 60000,
+        });
+
+        results.push({
+          index: i + 1,
+          type: 'image',
+          status: result.success ? 'success' : 'failed',
+          size: result.success ? formatBytes(result.size) : (result.error || 'unknown error'),
+        });
+      } catch (err) {
+        results.push({
+          index: i + 1,
+          type: 'image',
+          status: 'failed',
+          size: getErrorMessage(err),
+        });
+      }
+    }
+
+    return results;
+  },
+});

package/src/clis/pixiv/illusts.test.ts

@@ -0,0 +1,115 @@
+import { beforeAll, describe, expect, it } from 'vitest';
+import type { CliCommand } from '../../registry.js';
+import { getRegistry } from '../../registry.js';
+import { AuthRequiredError, CommandExecutionError } from '../../errors.js';
+import { createPageMock } from './test-utils.js';
+import './illusts.js';
+
+let cmd: CliCommand;
+
+beforeAll(() => {
+  cmd = getRegistry().get('pixiv/illusts')!;
+  expect(cmd?.func).toBeTypeOf('function');
+});
+
+describe('pixiv illusts', () => {
+  it('throws CommandExecutionError on invalid user ID', async () => {
+    const page = createPageMock([]);
+
+    await expect(cmd.func!(page, { 'user-id': 'abc', limit: 5 })).rejects.toThrow(CommandExecutionError);
+  });
+
+  it('throws AuthRequiredError on 401', async () => {
+    const page = createPageMock([{ __httpError: 401 }]);
+
+    await expect(cmd.func!(page, { 'user-id': '11', limit: 5 })).rejects.toThrow(AuthRequiredError);
+  });
+
+  it('throws generic error on non-auth HTTP failure', async () => {
+    const page = createPageMock([{ __httpError: 500 }]);
+
+    await expect(cmd.func!(page, { 'user-id': '11', limit: 5 })).rejects.toThrow(CommandExecutionError);
+  });
+
+  it('returns empty array when user has no illusts', async () => {
+    const page = createPageMock([
+      { body: { illusts: {} } },
+    ]);
+
+    const result = await cmd.func!(page, { 'user-id': '11', limit: 5 });
+    expect(result).toEqual([]);
+  });
+
+  it('fetches illust IDs then batch-fetches details', async () => {
+    const page = createPageMock([
+      // Step 1: profile/all returns illust IDs
+      {
+        body: {
+          illusts: { '99999': null, '88888': null, '77777': null },
+        },
+      },
+      // Step 2: batch detail response
+      {
+        body: {
+          works: {
+            '99999': {
+              id: '99999',
+              title: 'Latest Work',
+              pageCount: 2,
+              bookmarkCount: 300,
+              tags: ['original', 'fantasy'],
+              createDate: '2025-01-15T12:00:00+09:00',
+            },
+            '88888': {
+              id: '88888',
+              title: 'Older Work',
+              pageCount: 1,
+              bookmarkCount: 150,
+              tags: ['landscape'],
+              createDate: '2024-12-01T10:00:00+09:00',
+            },
+          },
+        },
+      },
+    ]);
+
+    const result = (await cmd.func!(page, { 'user-id': '11', limit: 3 })) as any[];
+
+    // Should be sorted newest first (99999 > 88888 > 77777)
+    expect(result).toHaveLength(2); // 77777 has no detail data, filtered out
+    expect(result[0]).toMatchObject({
+      rank: 1,
+      title: 'Latest Work',
+      illust_id: '99999',
+      pages: 2,
+      bookmarks: 300,
+      created: '2025-01-15',
+    });
+    expect(result[1]).toMatchObject({
+      rank: 2,
+      title: 'Older Work',
+      illust_id: '88888',
+    });
+  });
+
+  it('respects the limit on illust IDs fetched', async () => {
+    const page = createPageMock([
+      {
+        body: {
+          illusts: { '100': null, '200': null, '300': null, '400': null, '500': null },
+        },
+      },
+      {
+        body: {
+          works: {
+            '500': { id: '500', title: 'W5', pageCount: 1, bookmarkCount: 0, tags: [], createDate: '' },
+            '400': { id: '400', title: 'W4', pageCount: 1, bookmarkCount: 0, tags: [], createDate: '' },
+          },
+        },
+      },
+    ]);
+
+    const result = (await cmd.func!(page, { 'user-id': '11', limit: 2 })) as any[];
+    expect(result).toHaveLength(2);
+  });
+});

package/src/clis/pixiv/illusts.ts

@@ -0,0 +1,78 @@
+/**
+ * Pixiv illusts — list illustrations by an artist.
+ *
+ * Two-step process:
+ * 1. Fetch all illust IDs from the user's profile
+ * 2. Batch-fetch details for the most recent ones (max 48 IDs per request)
+ */
+
+import { cli, Strategy } from '../../registry.js';
+import { CommandExecutionError } from '../../errors.js';
+import { pixivFetch, BATCH_SIZE } from './utils.js';
+
+cli({
+  site: 'pixiv',
+  name: 'illusts',
+  description: "List a Pixiv artist's illustrations",
+  domain: 'www.pixiv.net',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'user-id', positional: true, required: true, help: 'Pixiv user ID' },
+    { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
+  ],
+  columns: ['rank', 'title', 'illust_id', 'pages', 'bookmarks', 'tags', 'created'],
+
+  func: async (page, kwargs) => {
+    const userId = String(kwargs['user-id'] ?? '');
+    const limit = Number(kwargs.limit) || 20;
+
+    if (!/^\d+$/.test(userId)) {
+      throw new CommandExecutionError(`Invalid user ID: ${userId}`);
+    }
+
+    // Step 1: get all illust IDs
+    const profileBody = await pixivFetch(page, `/ajax/user/${userId}/profile/all`, {
+      notFoundMsg: `User not found: ${userId}`,
+    });
+
+    const allIds = Object.keys(profileBody?.illusts || {})
+      .sort((a, b) => Number(b) - Number(a))
+      .slice(0, limit);
+
+    if (allIds.length === 0) return [];
+
+    // Step 2: batch fetch details (Pixiv supports up to ~48 IDs per request)
+    const allWorks: Record<string, any> = {};
+
+    for (let offset = 0; offset < allIds.length; offset += BATCH_SIZE) {
+      const batch = allIds.slice(offset, offset + BATCH_SIZE);
+      const idsParam = batch.map(id => `ids[]=${id}`).join('&');
+
+      // pixivFetch navigates on each call; for subsequent batches we re-navigate,
+      // which is fine — the cookie is already attached.
+      const detailBody = await pixivFetch(
+        page,
+        `/ajax/user/${userId}/profile/illusts?${idsParam}&work_category=illustManga&is_first_page=${offset === 0 ? 1 : 0}`,
+      );
+
+      Object.assign(allWorks, detailBody?.works || {});
+    }
+
+    return allIds
+      .map((id, i) => {
+        const w = allWorks[id];
+        if (!w) return null;
+        return {
+          rank: i + 1,
+          title: w.title || '',
+          illust_id: w.id,
+          pages: w.pageCount || 1,
+          bookmarks: w.bookmarkCount || 0,
+          tags: (w.tags || []).slice(0, 5).join(', '),
+          created: (w.createDate || '').split('T')[0],
+          url: 'https://www.pixiv.net/artworks/' + w.id,
+        };
+      })
+      .filter(Boolean);
+  },
+});

package/src/clis/pixiv/ranking.yaml

@@ -0,0 +1,53 @@
+site: pixiv
+name: ranking
+description: Pixiv illustration rankings (daily/weekly/monthly)
+domain: www.pixiv.net
+strategy: cookie
+browser: true
+
+args:
+  mode:
+    type: str
+    default: daily
+    description: Ranking mode
+    choices: [daily, weekly, monthly, rookie, original, male, female, daily_r18, weekly_r18]
+  page:
+    type: int
+    default: 1
+    description: Page number
+  limit:
+    type: int
+    default: 20
+    description: Number of results
+
+pipeline:
+  - navigate: https://www.pixiv.net
+
+  - evaluate: |
+      (async () => {
+        const mode = ${{ args.mode | json }};
+        const page = ${{ args.page | json }};
+        const limit = ${{ args.limit | json }};
+        const res = await fetch(
+          'https://www.pixiv.net/ranking.php?mode=' + mode + '&p=' + page + '&format=json',
+          { credentials: 'include' }
+        );
+        if (!res.ok) {
+          if (res.status === 401 || res.status === 403) throw new Error('Authentication required — please log in to Pixiv in Chrome');
+          throw new Error('Pixiv request failed (HTTP ' + res.status + ')');
+        }
+        const data = await res.json();
+        const items = (data?.contents || []).slice(0, limit);
+        return items.map((item, i) => ({
+          rank: item.rank,
+          title: item.title,
+          author: item.user_name,
+          user_id: item.user_id,
+          illust_id: item.illust_id,
+          pages: item.illust_page_count,
+          bookmarks: item.illust_bookmark_count,
+          url: 'https://www.pixiv.net/artworks/' + item.illust_id
+        }));
+      })()
+
+columns: [rank, title, author, illust_id, pages, bookmarks]

package/src/clis/pixiv/search.test.ts

@@ -0,0 +1,97 @@
+import { beforeAll, describe, expect, it } from 'vitest';
+import type { CliCommand } from '../../registry.js';
+import { getRegistry } from '../../registry.js';
+import { AuthRequiredError, CommandExecutionError } from '../../errors.js';
+import { createPageMock } from './test-utils.js';
+import './search.js';
+
+let cmd: CliCommand;
+
+beforeAll(() => {
+  cmd = getRegistry().get('pixiv/search')!;
+  expect(cmd?.func).toBeTypeOf('function');
+});
+
+describe('pixiv search', () => {
+  it('throws AuthRequiredError on 401', async () => {
+    const page = createPageMock([{ __httpError: 401 }]);
+
+    await expect(cmd.func!(page, { query: '初音ミク', limit: 5 })).rejects.toThrow(AuthRequiredError);
+  });
+
+  it('throws generic error on non-auth HTTP failure', async () => {
+    const page = createPageMock([{ __httpError: 500 }]);
+
+    await expect(cmd.func!(page, { query: 'test', limit: 5 })).rejects.toThrow(CommandExecutionError);
+  });
+
+  it('returns ranked results with correct fields', async () => {
+    const page = createPageMock([
+      {
+        body: {
+          illust: {
+            data: [
+              {
+                id: '12345',
+                title: 'Miku Illustration',
+                userName: 'artist1',
+                userId: '100',
+                pageCount: 3,
+                bookmarkCount: 500,
+                tags: ['初音ミク', 'VOCALOID', 'ミク'],
+              },
+              {
+                id: '67890',
+                title: 'Another Art',
+                userName: 'artist2',
+                userId: '200',
+                pageCount: 1,
+                bookmarkCount: 100,
+                tags: ['オリジナル'],
+              },
+            ],
+          },
+        },
+      },
+    ]);
+
+    const result = (await cmd.func!(page, { query: '初音ミク', limit: 10 })) as any[];
+
+    expect(result).toHaveLength(2);
+    expect(result[0]).toMatchObject({
+      rank: 1,
+      title: 'Miku Illustration',
+      author: 'artist1',
+      illust_id: '12345',
+      pages: 3,
+      bookmarks: 500,
+    });
+    expect(result[1]).toMatchObject({ rank: 2, illust_id: '67890' });
+  });
+
+  it('respects the limit parameter', async () => {
+    const page = createPageMock([
+      {
+        body: {
+          illust: {
+            data: [
+              { id: '1', title: 'A', userName: 'u1', userId: '1', pageCount: 1, bookmarkCount: 0, tags: [] },
+              { id: '2', title: 'B', userName: 'u2', userId: '2', pageCount: 1, bookmarkCount: 0, tags: [] },
+              { id: '3', title: 'C', userName: 'u3', userId: '3', pageCount: 1, bookmarkCount: 0, tags: [] },
+            ],
+          },
+        },
+      },
+    ]);
+
+    const result = (await cmd.func!(page, { query: 'test', limit: 2 })) as any[];
+    expect(result).toHaveLength(2);
+  });
+
+  it('returns empty array when no results', async () => {
+    const page = createPageMock([{ body: { illust: { data: [] } } }]);
+
+    const result = await cmd.func!(page, { query: 'nonexistent', limit: 10 });
+    expect(result).toEqual([]);
+  });
+});

package/src/clis/pixiv/search.ts

@@ -0,0 +1,53 @@
+/**
+ * Pixiv search — search illustrations by keyword/tag.
+ *
+ * Uses the internal Ajax search API with browser cookies for authentication.
+ */
+
+import { cli, Strategy } from '../../registry.js';
+import { pixivFetch } from './utils.js';
+
+cli({
+  site: 'pixiv',
+  name: 'search',
+  description: 'Search Pixiv illustrations by keyword',
+  domain: 'www.pixiv.net',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'query', positional: true, required: true, help: 'Search keyword or tag' },
+    { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
+    { name: 'order', type: 'str', default: 'date_d', help: 'Sort order', choices: ['date_d', 'date', 'popular_d', 'popular_male_d', 'popular_female_d'] },
+    { name: 'mode', type: 'str', default: 'all', help: 'Search mode', choices: ['all', 'safe', 'r18'] },
+    { name: 'page', type: 'int', default: 1, help: 'Page number' },
+  ],
+  columns: ['rank', 'title', 'author', 'illust_id', 'pages', 'bookmarks', 'tags'],
+
+  func: async (page, kwargs) => {
+    const { query, limit = 20, order = 'date_d', mode = 'all', page: pageNum = 1 } = kwargs;
+    const encoded = encodeURIComponent(query);
+
+    // Pixiv search API requires the keyword in BOTH the URL path and the `word` query param.
+    const body = await pixivFetch(
+      page,
+      `/ajax/search/illustrations/${encoded}`,
+      { params: { word: query, order, mode, p: pageNum, s_mode: 's_tag_full', type: 'illust_and_ugoira' } },
+    );
+
+    const items: any[] = body?.illust?.data || [];
+
+    return items
+      .filter((item: any) => item.id)
+      .slice(0, Number(limit))
+      .map((item: any, i: number) => ({
+        rank: i + 1,
+        title: item.title || '',
+        author: item.userName || '',
+        user_id: item.userId || '',
+        illust_id: item.id,
+        pages: item.pageCount || 1,
+        bookmarks: item.bookmarkCount || 0,
+        tags: (item.tags || []).slice(0, 5).join(', '),
+        url: 'https://www.pixiv.net/artworks/' + item.id,
+      }));
+  },
+});

package/src/clis/pixiv/test-utils.ts

@@ -0,0 +1,29 @@
+import { vi } from 'vitest';
+import type { IPage } from '../../types.js';
+
+/**
+ * Create a minimal page mock with only the methods commonly used by Pixiv adapters.
+ *
+ * Since all TS adapters now go through `pixivFetch` which calls `page.evaluate`,
+ * the evaluate results should match the raw Pixiv Ajax response format:
+ * - Success: `{ body: ... }` (pixivFetch returns the `body` field)
+ * - HTTP error: `{ __httpError: <status> }` (pixivFetch detects and throws)
+ *
+ * Additional methods can be overridden via the overrides parameter.
+ */
+export function createPageMock(
+  evaluateResults: any[],
+  overrides?: Partial<IPage>,
+): IPage {
+  const evaluate = vi.fn();
+  for (const result of evaluateResults) {
+    evaluate.mockResolvedValueOnce(result);
+  }
+
+  return {
+    goto: vi.fn().mockResolvedValue(undefined),
+    evaluate,
+    getCookies: vi.fn().mockResolvedValue([]),
+    ...overrides,
+  } as unknown as IPage;
+}

package/src/clis/pixiv/user.yaml

@@ -0,0 +1,46 @@
+site: pixiv
+name: user
+description: View Pixiv artist profile
+domain: www.pixiv.net
+strategy: cookie
+browser: true
+
+args:
+  uid:
+    type: str
+    required: true
+    positional: true
+    description: Pixiv user ID
+
+pipeline:
+  - navigate: https://www.pixiv.net
+
+  - evaluate: |
+      (async () => {
+        const uid = ${{ args.uid | json }};
+        const res = await fetch(
+          'https://www.pixiv.net/ajax/user/' + uid + '?full=1',
+          { credentials: 'include' }
+        );
+        if (!res.ok) {
+          if (res.status === 401 || res.status === 403) throw new Error('Authentication required — please log in to Pixiv in Chrome');
+          if (res.status === 404) throw new Error('User not found: ' + uid);
+          throw new Error('Pixiv request failed (HTTP ' + res.status + ')');
+        }
+        const data = await res.json();
+        const b = data?.body;
+        if (!b) throw new Error('User not found');
+        return [{
+          user_id: uid,
+          name: b.name,
+          premium: b.premium ? 'Yes' : 'No',
+          following: b.following,
+          illusts: typeof b.illusts === 'object' ? Object.keys(b.illusts).length : (b.illusts || 0),
+          manga: typeof b.manga === 'object' ? Object.keys(b.manga).length : (b.manga || 0),
+          novels: typeof b.novels === 'object' ? Object.keys(b.novels).length : (b.novels || 0),
+          comment: (b.comment || '').slice(0, 80),
+          url: 'https://www.pixiv.net/users/' + uid
+        }];
+      })()
+
+columns: [user_id, name, premium, following, illusts, manga, novels, comment]