@miso.ai/doggoganger 0.9.0-beta.10

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,33 @@
+name: NPM publish
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish-npm:
+    environment: production
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get version
+        id: version
+        run: |
+          VERSION=${{ github.event.release.tag_name }}
+          echo "::set-output name=version::$(echo $VERSION | sed -e 's/v//gI')"
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: 16
+          registry-url: https://registry.npmjs.org/
+      - run: npm install
+      - run: git config --global user.name "${{ github.actor }}"
+      - run: git config --global user.email "github-action-${{ github.actor }}@users.noreply.github.com"
+      - run: npm run version ${{ steps.version.outputs.version }}
+      - run: npm publish
+        if: "!github.event.release.prerelease"
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+      - run: npm publish --tag beta
+        if: "github.event.release.prerelease"
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Miso Technologies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,2 @@
+# doggoganger
+Mock API endpoint service for demo and testing

package/bin/version.js

@@ -0,0 +1,46 @@
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { writeFileSync, readFileSync, existsSync } from 'fs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const VERSION_REGEXP = /^\d+\.\d+\.\d+(?:-beta\.\d+)?$/;
+const version = process.argv[2];
+
+if (!version) {
+  console.log(`Usage: npm run version [version]`);
+  process.exit();
+}
+if (!VERSION_REGEXP.test(version)) {
+  console.error(`Illegal version: ${version}`);
+  process.exit(1);
+}
+
+const rootDir = join(__dirname, '..');
+//const VERSION_FILE_NAME = 'src/version.js';
+const PACKAGE_FILE_NAME = 'package.json';
+
+/*
+function writeVersionFile(path, version) {
+  const filePath = join(rootDir, path, VERSION_FILE_NAME);
+  if (existsSync(filePath)) {
+    writeFileSync(filePath, `export default '${version}';`);
+  }
+}
+*/
+
+function readPackageFileSync(path) {
+  const file = join(path, PACKAGE_FILE_NAME);
+  return existsSync(file) ? JSON.parse(readFileSync(file)) : undefined;
+}
+
+function writePackageFileSync(path, data) {
+  const file = join(path, PACKAGE_FILE_NAME);
+  if (!existsSync(file)) {
+    mkdirSync(dirname(file), { recursive: true });
+  }
+  writeFileSync(join(path, PACKAGE_FILE_NAME), JSON.stringify(data, null, 2));
+}
+
+const { name, version: _version, ...project } = readPackageFileSync(rootDir);
+writePackageFileSync(rootDir, { name, version, ...project });

package/cli/index.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+import { fileURLToPath } from 'url';
+import { dirname, resolve, join } from 'path';
+import nodemon from 'nodemon';
+import yargs from 'yargs/yargs';
+import { hideBin } from 'yargs/helpers';
+import doggoganger from '../src/index.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SRC_DIR = join(__dirname, '../src');
+
+let { watch, ...argv } = yargs(hideBin(process.argv))
+  .option('port', {
+    alias: 'p',
+    describe: 'Port of mock API endpoint',
+    default: 9901,
+    type: 'number',
+  })
+  .option('watch', {
+    alias: 'w',
+    describe: 'Watch files for changes',
+    type: 'boolean',
+  })
+  .option('answer-format', {
+    describe: 'Answer field format in answers API response',
+    type: 'string',
+  })
+  .option('serve', {
+    alias: 's',
+    describe: 'Serve static files as well',
+    type: 'boolean',
+  })
+  .argv;
+
+const { port, serve, ['answer-format']: answerFormat } = argv;
+argv = { port, serve, answerFormat };
+
+if (watch) {
+  const exec = `node ${resolve(__dirname, 'server.js')} ${JSON.stringify(JSON.stringify(argv))}`;
+  nodemon({
+    exec,
+    watch: argv.static ? [SRC_DIR, '.'] : SRC_DIR,
+    ignore: ['*/node_modules/*'],
+    //ext: 'js json yaml',
+    verbose: true,
+  }).on('log', ({ colour }) => {
+    console.log(colour);
+  }).on('quit', () => process.exit());
+  
+} else {
+  doggoganger(argv);
+}

package/cli/server.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import doggoganger from '../src/index.js';
+
+doggoganger(JSON.parse(process.argv[2]));

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@miso.ai/doggoganger",
+  "version": "0.9.0-beta.10",
+  "description": "A dummy miso endpoint for demo and testing",
+  "type": "module",
+  "bin": {
+    "doggoganger": "cli/index.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "start": "nodemon src/index.js",
+    "version": "node ./bin/version.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MisoAI/doggoganger.git"
+  },
+  "homepage": "https://github.com/MisoAI/doggoganger/",
+  "license": "MIT",
+  "contributors": [
+    "simonpai <simon.pai@askmiso.com>"
+  ],
+  "bugs": {
+    "url": "https://github.com/MisoAI/doggoganger/issues"
+  },
+  "dependencies": {
+    "@koa/cors": "^4.0.0",
+    "@koa/router": "^12.0.0",
+    "js-yaml": "^4.1.0",
+    "koa": "^2.14.1",
+    "koa-body": "^6.0.1",
+    "koa-static": "^5.0.0",
+    "nodemon": "^2.0.15",
+    "uuid": "^8.3.2",
+    "yargs": "^17.5.1"
+  }
+}

package/src/api/ask.js

@@ -0,0 +1,147 @@
+import Router from '@koa/router';
+import { v4 as uuid } from 'uuid';
+import { lorem, md, articles, utils } from '../data/index.js';
+import { parseBodyIfNecessary } from './utils.js';
+
+const { randomInt } = utils;
+
+const CPS = 100;
+const ITEMS_LOADING_TIME = 3;
+const STAGES = [
+  {
+    name: 'fetch',
+    duration: 1.5,
+    text: `Checking the question and fetching results... `,
+  },
+  {
+    name: 'verify',
+    duration: 1.5,
+    text: `Verifying results... `,
+  },
+  {
+    name: 'generate',
+    duration: 1.5,
+    text: `Generating answer... `,
+  },
+];
+
+function formatDatetime(timestamp) {
+  const str = new Date(timestamp).toISOString();
+  return str.endsWith('Z') ? str.slice(0, -1) : str;
+}
+
+function answer(format) {
+  switch (format) {
+    case 'markdown':
+      return md.markdown({});
+    case 'plaintext':
+    default:
+      return lorem.lorem({
+        min: 50,
+        max: 100,
+        decorates: ['description'],
+      });
+  }
+}
+
+const answers = new Map();
+
+class Answer {
+
+  constructor(question, previous_question_id, { answerFormat = 'markdown' } = {}) {
+    this.question_id = uuid();
+    this.question = question;
+    this.previous_answer_id = previous_question_id;
+    this.timestamp = Date.now();
+    this.datetime = formatDatetime(this.timestamp);
+
+    this.answer = answer(answerFormat);
+    this.relatedResources = [...articles({ rows: randomInt(6, 8) })];
+    this.sources = [...articles({ rows: randomInt(4, 6) })];
+
+    this.previous_question_id = previous_question_id && answers.get(previous_question_id) || undefined;
+    answers.set(this.question_id, this);
+  }
+
+  get id() {
+    return this.question_id;
+  }
+
+  get() {
+    const now = Date.now();
+    const elapsed = (now - this.timestamp) / 1000;
+    const [answer_stage, answer, finished] = this._answer(elapsed);
+    const sources = this._sources(elapsed);
+    const related_resources = this._relatedResources(elapsed);
+    const { question_id, question, datetime, previous_question_id } = this;
+
+    return {
+      affiliation: undefined,
+      answer,
+      answer_stage,
+      datetime,
+      finished,
+      previous_question_id,
+      question,
+      question_id,
+      related_resources,
+      sources,
+    };
+  }
+
+  _answer(elapsed) {
+    for (const stage of STAGES) {
+      elapsed -= stage.duration;
+      if (elapsed < 0) {
+        return [stage.name, stage.text, false];
+      }
+    }
+    const length = Math.floor(elapsed * CPS);
+    const finished = length >= this.answer.length;
+    const text = finished ? this.answer : this.answer.slice(0, length);
+    return ['result', text, finished];
+  }
+
+  _sources(elapsed) {
+    const { sources } = this;
+    const { length } = sources;
+    const loaded = Math.floor(length * elapsed / ITEMS_LOADING_TIME);
+    return sources.slice(0, loaded);
+  }
+
+  _relatedResources(elapsed) {
+    const { relatedResources } = this;
+    const { length } = relatedResources;
+    const loaded = Math.floor(length * elapsed / ITEMS_LOADING_TIME);
+    return relatedResources.slice(0, loaded);
+  }
+
+}
+
+export default function({ answerFormat }) {
+  const options = Object.freeze({ answerFormat });
+  const router = new Router();
+
+  router.post('/questions', (ctx) => {
+    const { question, previous_answer_id } = parseBodyIfNecessary(ctx.request.body);
+    const answerFormat = ctx.get('x-answer-format') || options.answerFormat;
+    const answer = new Answer(question, previous_answer_id, { answerFormat });
+    const data = {
+      question_id: answer.id,
+    };
+    ctx.body = JSON.stringify({ data });
+  });
+
+  router.get('/questions/:id/answer', (ctx) => {
+    const { id } = ctx.params;
+    const answer = answers.get(id);
+    if (!answer) {
+      ctx.status = 404;
+    } else {
+      const data = answer.get();
+      ctx.body = JSON.stringify({ data });
+    }
+  });
+
+  return router;
+}

package/src/api/handlers.js

@@ -0,0 +1,11 @@
+import { products as _products } from '../data/index.js';
+import { parseBodyIfNecessary } from './utils.js';
+
+export function products(ctx) {
+  const { rows = 5 } = parseBodyIfNecessary(ctx.request.body);
+  ctx.body = {
+    data: {
+      products: [..._products({ rows })],
+    },
+  };
+}

package/src/api/index.js

@@ -0,0 +1,20 @@
+import Router from '@koa/router';
+import ask from './ask.js';
+import recommendation from './recommendation.js';
+import search from './search.js';
+import interactions from './interactions.js';
+
+function use(router, path, middleware) {
+  router.use(path, middleware.routes(), middleware.allowedMethods());
+}
+
+export default function(options) {
+  const router = new Router();
+
+  use(router, '/ask', ask(options));
+  use(router, '/recommendation', recommendation);
+  use(router, '/search', search);
+  use(router, '/interactions', interactions);
+
+  return router;
+};

package/src/api/interactions.js

@@ -0,0 +1,9 @@
+import Router from '@koa/router';
+
+const router = new Router();
+
+router.post('/', (ctx) => {
+  ctx.body = { took: 1, errors: false, data: [] };
+});
+
+export default router;

package/src/api/recommendation.js

@@ -0,0 +1,9 @@
+import Router from '@koa/router';
+import { products } from './handlers.js';
+
+const router = new Router();
+
+router.post('/user_to_products', products);
+router.post('/product_to_products', products);
+
+export default router;

package/src/api/search.js

@@ -0,0 +1,8 @@
+import Router from '@koa/router';
+import { products } from './handlers.js';
+
+const router = new Router();
+
+router.post('/search', products);
+
+export default router;

package/src/api/utils.js

@@ -0,0 +1,6 @@
+export function parseBodyIfNecessary(body) {
+  if (typeof body === 'string') {
+    return JSON.parse(body);
+  }
+  return body;
+}

package/src/data/articles.js

@@ -0,0 +1,24 @@
+import * as u from './utils.js';
+import * as fields from './fields.js';
+
+export function *articles({ rows, ...options } = {}) {
+  for (let i = 0; i < rows; i++) {
+    yield article({ ...options, index: i });
+  }
+}
+
+function article({} = {}) {
+  const id = u.id();
+
+  return {
+    product_id: id,
+    authors: fields.authors(),
+    categories: [],
+    tags: fields.tags(),
+    title: fields.title({ size: [4, 10] }),
+    snippet: fields.description({ size: [20, 40] }),
+    //html,
+    cover_image: fields.image(),
+    url: `/products/${id}`,
+  };
+}

package/src/data/fields.js

@@ -0,0 +1,49 @@
+import * as lorem from './lorem.js';
+import { imageUrl } from './utils.js';
+
+export function image({ size = 300 } = {}) {
+  return imageUrl(size);
+}
+
+export function authors({ size = [1, 3] } = {}) {
+  return lorem.lorem({
+    size,
+    decorates: ['title'],
+    output: 'array',
+  });
+}
+
+export function tags({ size = [1, 4] } = {}) {
+  return lorem.lorem({
+    size,
+    output: 'array',
+  });
+}
+
+// TODO: categories
+
+export function title({ size = [2, 6] } = {}) {
+  return lorem.lorem({
+    size,
+    decorates: ['title'],
+  });
+}
+
+export function description({ size = [10, 20] } = {}) {
+  return lorem.lorem({
+    size,
+    decorates: ['description'],
+  });
+}
+
+export function availability() {
+  return Math.random() > 0.3 ? 'IN_STOCK' : 'OUT_OF_STOCK';
+}
+
+export function price() {
+  return Math.floor(Math.random() * 10000) / 100;
+}
+
+export function rating() {
+  return Math.floor(Math.random() * 500) / 100 + 1;
+}

package/src/data/index.js

@@ -0,0 +1,5 @@
+export * as md from './markdown/index.js';
+export * as lorem from './lorem.js';
+export * from './products.js';
+export * from './articles.js';
+export * as utils from './utils.js';

package/src/data/lorem.js

@@ -0,0 +1,156 @@
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, resolve } from 'path';
+import yaml from 'js-yaml';
+import { randomInt } from './utils.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const DEFAULT_WORDS = yaml.load(readFileSync(resolve(__dirname, './words.yaml'), 'utf8'));
+
+export function lorem({ decorates = [], output = 'string', size, min, max, ...options } = {}) {
+  let iterator = limit(size || [min, max])(base(options));
+  for (const decorate of decorates) {
+    iterator = lookup(decorate)(iterator);
+  }
+  return lookup(output)(iterator);
+}
+
+const FNS = {
+  string,
+  array,
+  title,
+  description,
+  multiline,
+}
+
+function lookup(fn) {
+  return typeof fn === 'string' ? FNS[fn]() : fn;
+}
+
+// base //
+export function *base({ words = DEFAULT_WORDS, fixedStarts = 0 } = {}) {
+  const wordsLength = words.length;
+  for (let i = 0; ; i++) {
+    yield words[i < fixedStarts ? i : Math.floor(Math.random() * wordsLength)];
+  }
+}
+
+// output //
+export function string({ separator = ' ' } = {}) {
+  return iterator => [...iterator].join(separator);
+}
+
+export function array() {
+  return iterator => [...iterator];
+}
+
+export function multiline({
+  wordsPerLine = {
+    avg: 10,
+    std: 3,
+    min: 1,
+  },
+} = {}) {
+  return iterator => {
+    let slen = gaussMS(wordsPerLine);
+    let result = '';
+    for (let word of iterator) {
+      if (result) {
+        if (slen-- === 0) {
+          result += '\n';
+          slen = gaussMS(wordsPerLine);
+        } else {
+          result += ' ';
+        }
+      }
+      result += word;
+    }
+    return result;
+  }
+}
+
+// decorators //
+export function limit(size = [5, 10]) {
+  const n = typeof size === 'number' ? size : randomInt(...size);
+  return function *(iterator) {
+    let i = 0;
+    for (let word of iterator) {
+      if (i++ >= n) {
+        break;
+      }
+      yield word;
+    }
+  };
+}
+
+export function title({} = {}) {
+  return function *(iterator) {
+    for (let word of iterator) {
+      yield capitalize(word);
+    }
+  };
+}
+
+export function description({
+  wordsPerSentence = {
+    avg: 24,
+    std: 5,
+    min: 1,
+  },
+} = {}) {
+  return function *(iterator) {
+    let word;
+    let slen = 0;
+    for (let _word of iterator) {
+      if (word) {
+        yield word;
+      }
+      word = _word;
+      if (slen === 0) {
+        word = capitalize(word);
+        slen = gaussMS(wordsPerSentence);
+      }
+      if (--slen === 0) {
+        word += '.';
+      }
+    }
+    if (word) {
+      if (!word.endsWith('.')) {
+        word += '.';
+      }
+      yield word;
+    }
+  };
+}
+
+// helpers //
+function capitalize(word) {
+  return word[0].toUpperCase() + word.substring(1);
+}
+
+// TODO: have a random variable expression
+function gaussMS(args) {
+  if (typeof args === 'number') {
+    return Math.round(avg);
+  }
+  let { avg, std, min, max } = args;
+  if (std === undefined) {
+    std = avg / 4;
+  }
+  let n = gaussRandom() * std + avg;
+  if (min !== undefined) {
+    n = Math.max(min, n);
+  }
+  if (max !== undefined) {
+    n = Math.min(max, n);
+  }
+  return Math.round(n);
+}
+
+function gaussRandom() {
+  return uniformRandom() + uniformRandom() + uniformRandom();
+}
+
+function uniformRandom() {
+  return Math.random() * 2 - 1;
+}

package/src/data/markdown/index.js

@@ -0,0 +1,234 @@
+import { randomInt, imageUrl, shuffle } from '../utils.js';
+import * as lorem from '../lorem.js';
+
+// TODO: wild mode that generates edge cases
+
+export function markdown({ features, blocks = [8, 12] } = {}) {
+  // TODO: block features
+  return [
+    atxHeading({ features }),
+    paragraph({ features }),
+    fencedCodeBlock({ features }),
+    paragraph({ features }),
+    table({ features }),
+    image(),
+    paragraph({ features }),
+    hr(),
+    atxHeading({ features }),
+    paragraph({ features }),
+    list({ features }),
+    paragraph({ features }),
+  ].join('\n\n');
+}
+
+// leaf blocks //
+export function hr() {
+  // wild mode: while spaces at the beginning (< 4), in between, in the end
+  // wild mode: no line break for '*'
+  return '*-_'.charAt(randomInt(0, 2)).repeat(randomInt(3, 6));
+}
+
+export function atxHeading({ features, level = [1, 6], size = [1, 8], content }) {
+  const words = content || lorem.lorem({ size });
+  return `${'#'.repeat(randomInt(...level))} ${words}`;
+}
+
+export function setextHeading({ features, level = [1, 2], size = [1, 8], content }) {
+  const words = content || lorem.lorem({ size });
+  return `${words}\n${'=-'.charAt(randomInt(...level) - 1).repeat(3)}`;
+}
+
+export function linkReferenceDefinition({ label, destination, title }) {
+  return `[${label}]: ${destination}${title !== undefined ? ` ${title}` : ''}`;
+}
+
+export function indentedCodeBlock({ lang, content, size }) {
+  content = content || codeContent({ lang, size }); 
+  return indent(4, content);
+}
+
+export function fencedCodeBlock({ lang, content, size, fenceChar = '`' }) {
+  if (fenceChar === 'random') {
+    fenceChar = '`~'.charAt(randomInt(0, 1));
+  }
+  content = content || codeContent({ lang, size }); 
+  // TODO: escape fenceChar in content
+  return `${fenceChar.repeat(3)}${lang || ''}\n${content}\n${fenceChar.repeat(3)}`;
+}
+
+export function paragraph({ features, size = [20, 50] }) {
+  return lorem.lorem({ size, decorates: ['description', decorate({ features })] });
+}
+
+export function table({ features, columns = [2, 4], rows = [2, 8] }) {
+  columns = randomInt(...columns);
+  rows = randomInt(...rows);
+  const defs = [...multiply({ size: 1 }, columns - 1), { size: [3, 8] }];
+  const header = lorem.lorem({ size: columns, output: 'array' });
+  const delimiter = defs.map(() => '---');
+  const body = [ header, delimiter ];
+  for (let i = 0; i < rows - 1; i++) {
+    body.push(defs.map(({ size }) => lorem.lorem({ size })));
+  }
+  return body.map(tableRow).join('\n');
+}
+
+export function image({ url, imageSize = [400, 250], ...options } = {}) {
+  url = url || imageUrl(imageSize);
+  return `![${_content(options)}](${url})`;
+}
+
+// container blocks //
+export function blockquote({ features, size = [3, 5] }) {
+  // TODO
+  return _blockquote(lorem.lorem({ size }));
+}
+
+const LIST_ITEM_TYPES = ['ordered', 'bullet', 'task'];
+
+export function list({ features, type = 'random', count = [1, 8], size = [5, 15] }) {
+  count = typeof count === 'number' ? count : randomInt(...count);
+  const t = type === 'random' ? LIST_ITEM_TYPES[Math.floor(3 * Math.random())] : type;
+  const items = [];
+  while (count > 0) {
+    const c = randomInt(1, count);
+    let content = paragraph({ features, size });
+    if (c > 1) {
+      content += `\n${list({ features, type, count: c - 1, size })}`;
+    }
+    items.push(listItem(t, content));
+    count -= c;
+  }
+  return items.join('\n');
+}
+
+// inline //
+export function codeSpan(options) {
+  return `\`${_content(options)}\``;
+}
+
+export function emphasis({ level = [1, 3], options }) {
+  level = typeof level === 'number' ? level : randomInt(...level);
+  const str = '_*'.charAt(randomInt(0, 1)).repeat(level);
+  return `${str}${_content(options)}${str}`;
+}
+
+export function link({ url = 'https://miso.ai', ...options } = {}) {
+  return `[${_content(options)}](${url})`;
+}
+
+// TODO: ref link
+// TODO: autolink
+// TODO: hard line break
+
+const INLINE_FEATURES = {
+  'code-span': () => ['`', '`'],
+  'emphasis-1': () => multiply(_emphasisAdfix(1), 2),
+  'emphasis-2': () => multiply(_emphasisAdfix(2), 2),
+  'emphasis-3': () => multiply(_emphasisAdfix(3), 2),
+  'strikethrough': () => ['~', '~'],
+  'link': ({ url = 'https://miso.ai' } = {}) => [`[`, `](${url})`],
+};
+
+function _emphasisAdfix(level = [1, 3]) {
+  level = typeof level === 'number' ? level : randomInt(...level);
+  return '_*'.charAt(randomInt(0, 1)).repeat(level);
+}
+
+const INLINE_FEATURE_LIST = Object.keys(INLINE_FEATURES);
+const INLINE_FEATURE_SET = new Set(INLINE_FEATURE_LIST);
+
+// decorator //
+export function decorate({ features = INLINE_FEATURE_LIST, size = [1, 3], rest = [0, 8] } = {}) {
+  features = features.filter(f => INLINE_FEATURE_SET.has(f));
+
+  const unused = shuffle([...features]);
+  let unusedCursor = unused.length - 1;
+
+  const rollRest = () => typeof rest === 'number' ? rest : randomInt(...rest);
+  const rollFeatureSize = () => typeof size === 'number' ? size : randomInt(...size);
+  const rollFeatureType = () => unusedCursor >= 0 ? unused[unusedCursor--] : features[randomInt(0, features.length - 1)];
+
+  return function *(iterator) {
+    let count = rollRest();
+    let suffix;
+    let lastWord;
+    for (const word of iterator) {
+      if (lastWord) {
+        yield lastWord;
+      }
+      if (count === 0) {
+        if (suffix) {
+          lastWord = `${word}${suffix}`;
+          suffix = undefined;
+          count = rollRest();
+        } else {
+          const [prefix, s] = INLINE_FEATURES[rollFeatureType()]();
+          lastWord = `${prefix}${word}`;
+          suffix = s;
+          count = rollFeatureSize();
+        }
+      } else {
+        lastWord = word;
+        count--;
+      }
+    }
+    if (lastWord) {
+      yield suffix !== undefined ? `${lastWord}${suffix}` : lastWord;
+    }
+  };
+}
+
+// helper //
+function _content({ size = [1, 3], content } = {}) {
+  return content || lorem.lorem({ size });
+}
+
+function _blockquote(content) {
+  return content.split('\n').map(line => `> ${line}`).join('\n');
+}
+
+export function indent(size, content) {
+  return content.split('\n').map(line => ' '.repeat(size) + line).join('\n');
+}
+
+export function listItem(type, content) {
+  const [firstLine, restLines] = content.split('\n', 2);
+  const result = `${listItemPrefix(type)} ${firstLine}`;
+  const indentSize = type === 'ordered' ? 3 : 2;
+  return !restLines ? result : result + `\n${indent(indentSize, restLines)}`;
+}
+
+function listItemPrefix(type, checked = 'random') {
+  switch (type) {
+    case 'ordered':
+      return '1.';
+    case 'bullet':
+      return '-';
+    case 'task':
+      const mark = (checked === 'random' ? Math.random() < 0.5 : !!checked) ? 'x' : ' ';
+      return `- [${mark}]`;
+    default:
+      throw new Error(`unknown list item type: ${type}`);
+  }
+}
+
+function codeContent({ lang, size = [10, 30] }) {
+  // TODO
+  switch (lang) {
+    default:
+      return lorem.lorem({ output: 'multiline', size });
+  }
+}
+
+function tableRow(cells) {
+  return `| ${cells.join(' | ')} |`;
+}
+
+function multiply(obj, i) {
+  const arr = [];
+  for (let j = 0; j < i; j++) {
+    arr.push(typeof obj === 'function' ? obj() : obj);
+  }
+  return arr;
+}

package/src/data/products.js

@@ -0,0 +1,30 @@
+import * as u from './utils.js';
+import * as fields from './fields.js';
+
+export function *products({ rows, ...options } = {}) {
+  for (let i = 0; i < rows; i++) {
+    yield product({ ...options, index: i });
+  }
+}
+
+function product({} = {}) {
+  const id = u.id();
+  const prices = u.repeat(fields.price, [1, 2]);
+  prices.sort();
+
+  return {
+    product_id: id,
+    authors: fields.authors(),
+    categories: [],
+    tags: fields.tags(),
+    title: fields.title(),
+    description: fields.description(),
+    //html,
+    cover_image: fields.image(),
+    url: `/products/${id}`,
+    sale_price: prices[0],
+    original_price: prices[prices.length - 1],
+    rating: fields.rating(),
+    availability: fields.availability(),
+  };
+}

package/src/data/utils.js

@@ -0,0 +1,31 @@
+export function randomInt(min, max) {
+  return max == null || (max <= min) ? min : (min + Math.floor(Math.random() * (max - min)));
+}
+
+// TODO: pass in size
+export function repeat(fn, range) {
+  const n = randomInt(...range);
+  const result = [];
+  for (let i = 0; i < n; i++) {
+    result.push(fn());
+  }
+  return result;
+}
+
+export function id() {
+  return Math.random().toString(36).substring(2, 10);
+}
+
+export function shuffle(array) {
+  for (let i = array.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [array[i], array[j]] = [array[j], array[i]];
+  }
+  return array;
+}
+
+export function imageUrl(size) {
+  const seed = Math.floor(Math.random() * 1000);
+  const sizePath = Array.isArray(size) ? size.length > 1 ? `${size[0]}/${size[1]}` : `${size[0]}` : `${size}`;
+  return `https://picsum.photos/seed/${seed}/${sizePath}`;
+}

package/src/data/words.yaml

@@ -0,0 +1,178 @@
+- lorem
+- ipsum
+- dolor
+- sit
+- amet
+- consectetur
+- adipiscing
+- elit
+- curabitur
+- vel
+- hendrerit
+- libero
+- eleifend
+- blandit
+- nunc
+- ornare
+- odio
+- ut
+- orci
+- gravida
+- imperdiet
+- nullam
+- purus
+- lacinia
+- a
+- pretium
+- quis
+- congue
+- praesent
+- sagittis
+- laoreet
+- auctor
+- mauris
+- non
+- velit
+- eros
+- dictum
+- proin
+- accumsan
+- sapien
+- nec
+- massa
+- volutpat
+- venenatis
+- sed
+- eu
+- molestie
+- lacus
+- quisque
+- porttitor
+- ligula
+- dui
+- mollis
+- tempus
+- at
+- magna
+- vestibulum
+- turpis
+- ac
+- diam
+- tincidunt
+- id
+- condimentum
+- enim
+- sodales
+- in
+- hac
+- habitasse
+- platea
+- dictumst
+- aenean
+- neque
+- fusce
+- augue
+- leo
+- eget
+- semper
+- mattis
+- tortor
+- scelerisque
+- nulla
+- interdum
+- tellus
+- malesuada
+- rhoncus
+- porta
+- sem
+- aliquet
+- et
+- nam
+- suspendisse
+- potenti
+- vivamus
+- luctus
+- fringilla
+- erat
+- donec
+- justo
+- vehicula
+- ultricies
+- varius
+- ante
+- primis
+- faucibus
+- ultrices
+- posuere
+- cubilia
+- curae
+- etiam
+- cursus
+- aliquam
+- quam
+- dapibus
+- nisl
+- feugiat
+- egestas
+- class
+- aptent
+- taciti
+- sociosqu
+- ad
+- litora
+- torquent
+- per
+- conubia
+- nostra
+- inceptos
+- himenaeos
+- phasellus
+- nibh
+- pulvinar
+- vitae
+- urna
+- iaculis
+- lobortis
+- nisi
+- viverra
+- arcu
+- morbi
+- pellentesque
+- metus
+- commodo
+- ut
+- facilisis
+- felis
+- tristique
+- ullamcorper
+- placerat
+- aenean
+- convallis
+- sollicitudin
+- integer
+- rutrum
+- duis
+- est
+- etiam
+- bibendum
+- donec
+- pharetra
+- vulputate
+- maecenas
+- mi
+- fermentum
+- consequat
+- suscipit
+- aliquam
+- habitant
+- senectus
+- netus
+- fames
+- quisque
+- euismod
+- curabitur
+- lectus
+- elementum
+- tempor
+- risus
+- cras

package/src/index.js

@@ -0,0 +1,28 @@
+import Koa from 'koa';
+import Router from '@koa/router';
+import cors from '@koa/cors';
+import serveStatic from 'koa-static';
+import { koaBody } from 'koa-body';
+import _api from './api/index.js';
+import { exclusion } from './utils.js';
+
+export default function doggoganger({ port = 9901, serve = false, ...options } = {}) {
+  const app = new Koa();
+  const router = new Router();
+  const api = _api(options);
+  
+  router.use('/api', api.routes(), api.allowedMethods());
+
+  if (serve) {
+    app
+      .use(exclusion)
+      .use(serveStatic('.'));
+  }
+
+  app
+    .use(cors())
+    .use(koaBody())
+    .use(router.routes())
+    .use(router.allowedMethods())
+    .listen(port);
+}

package/src/utils.js

@@ -0,0 +1,26 @@
+function shallServe(path) {
+  if (path.startsWith('/node_modules/') || path.startsWith('.')) {
+    return false;
+  }
+  const i = path.lastIndexOf('.');
+  const ext = i < 0 ? path.substring(i + 1) : '';
+  switch (ext) {
+    case 'md':
+      return false;
+  }
+  switch (path) {
+    case 'package.json':
+    case 'package-lock.json':
+      return false;
+  }
+  return true;
+}
+
+export async function exclusion(ctx, next) {
+  const { path } = ctx;
+  if (shallServe(path)) {
+    await next();
+  } else {
+    ctx.status = 404;
+  }
+}