@miso.ai/doggoganger 0.9.0-beta.9 → 0.9.1-beta.0

package/src/data/lorem.js

@@ -1,11 +1,5 @@
-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'));
+import { randomInt, gaussRandom } from './utils.js';
+import DEFAULT_WORDS from './words.js';
 
 export function lorem({ decorates = [], output = 'string', size, min, max, ...options } = {}) {
   let iterator = limit(size || [min, max])(base(options));
@@ -24,7 +18,18 @@ const FNS = {
 }
 
 function lookup(fn) {
-  return typeof fn === 'string' ? FNS[fn]() : fn;
+  switch (typeof fn) {
+    case 'string':
+      return FNS[fn]();
+    case 'function':
+      return fn;
+    case 'object':
+      if (Array.isArray(fn)) {
+        const [name, options = {}] = fn;
+        return FNS[name](options);
+      }
+  }
+  throw new Error(`Unrecognized decorator/output form: ${fn}`);
 }
 
 // base //
@@ -97,6 +102,7 @@ export function description({
     std: 5,
     min: 1,
   },
+  punctuation = '.',
 } = {}) {
   return function *(iterator) {
     let word;
@@ -111,12 +117,12 @@ export function description({
         slen = gaussMS(wordsPerSentence);
       }
       if (--slen === 0) {
-        word += '.';
+        word += punctuation;
       }
     }
     if (word) {
-      if (!word.endsWith('.')) {
-        word += '.';
+      if (!word.endsWith(punctuation)) {
+        word += punctuation;
       }
       yield word;
     }
@@ -146,11 +152,3 @@ function gaussMS(args) {
   }
   return Math.round(n);
 }
-
-function gaussRandom() {
-  return uniformRandom() + uniformRandom() + uniformRandom();
-}
-
-function uniformRandom() {
-  return Math.random() * 2 - 1;
-}

package/src/data/markdown/index.js

@@ -1,24 +1,55 @@
 import { randomInt, imageUrl, shuffle } from '../utils.js';
 import * as lorem from '../lorem.js';
+import * as languages from './languages.js';
 
 // TODO: wild mode that generates edge cases
 
-export function markdown({ features, blocks = [8, 12] } = {}) {
+function extractLangFeatures(features = []) {
+  const languages = new Set();
+  const rest = [];
+  for (const feature of features) {
+    if (feature.startsWith('lang-')) {
+      let lang = feature.slice(5);
+      if (lang === 'javascript') {
+        lang = 'js';
+      }
+      languages.add(lang);
+    } else {
+      rest.push(feature);
+    }
+  }
+  return [[...languages], rest];
+}
+
+export function markdown({ features, blocks = [8, 12], sampling = 1 } = {}) {
+  let languages = [];
+  [languages, features] = extractLangFeatures(features);
   // 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');
+  return sample([
+    () => atxHeading({ features }),
+    () => paragraph({ features }),
+    ...languages.map(lang => () => fencedCodeBlock({ lang, features })),
+    ...(languages.length ? [] : [() => fencedCodeBlock({ features })]),
+    () => paragraph({ features }),
+    () => table({ features }),
+    () => image(),
+    () => paragraph({ features }),
+    () => hr(),
+    () => atxHeading({ features }),
+    () => paragraph({ features }),
+    () => list({ features }),
+    () => paragraph({ features }),
+  ], sampling).join('\n\n');
+}
+
+function sample(fns, sampling) {
+  const arr = [];
+  for (const fn of fns) {
+    if (sampling >= 1 || Math.random() < sampling) {
+      arr.push(fn());
+    }
+  }
+  return arr;
 }
 
 // leaf blocks //
@@ -57,7 +88,8 @@ export function fencedCodeBlock({ lang, content, size, fenceChar = '`' }) {
 }
 
 export function paragraph({ features, size = [20, 50] }) {
-  return lorem.lorem({ size, decorates: ['description', decorate({ features })] });
+  // force all inline features
+  return lorem.lorem({ size, decorates: ['description', decorate()] });
 }
 
 export function table({ features, columns = [2, 4], rows = [2, 8] }) {
@@ -214,11 +246,7 @@ function listItemPrefix(type, checked = 'random') {
 }
 
 function codeContent({ lang, size = [10, 30] }) {
-  // TODO
-  switch (lang) {
-    default:
-      return lorem.lorem({ output: 'multiline', size });
-  }
+  return lang && languages[lang] ? languages[lang]() : lorem.lorem({ output: 'multiline', size });
 }
 
 function tableRow(cells) {

package/src/data/markdown/languages.js

@@ -0,0 +1,101 @@
+export function javascript() {
+  return JAVASCRIPT;
+}
+
+export function js() {
+  return JAVASCRIPT;
+}
+
+const JAVASCRIPT = `
+// module
+import { a, b } from './module';
+import * as module from './module';
+import module from './module';
+export default module;
+export const a = 0;
+export * from './module';
+export * as module from './module';
+
+// variables
+let a = 10;
+const b = 20;
+
+// function declaration
+function sum(x, y) {
+  return x + y;
+}
+
+// generator function
+function* iterator() {
+  yield 0;
+  yield 1;
+}
+
+// arrow function
+const multiply = (x, y) => x * y;
+
+// class
+class Person {
+  constructor(name, age) {
+    this.name = name;
+    this.age = age;
+  }
+
+  greet() {
+    console.log('Hello, my name is Miso.');
+  }
+}
+
+// primitive
+const str = 'Hello, world!';
+const num = 10.99;
+
+// object
+const person = new Person('John', 30);
+person.greet();
+
+// object literal
+const object = {
+  name: 'John',
+  [x]: 10,
+  ...props,
+};
+
+// array literal
+const arr = [1, 2, 3, 4, 5, ...props];
+
+// regexp literal
+const regexp = /\\w+/g;
+
+// operators
+const sum = a + b;
+const product = a * b;
+const negation = -a;
+const max = a > b ? a : b;
+
+// flow control
+let i = 9;
+for (const n of arr) {
+  if (n > i) {
+    console.log(n);
+  }
+  i++;
+}
+
+// async/await
+(async () => {
+  const result = await asyncFunction();
+})();
+
+// try/catch
+try {
+} catch (e) {
+}
+
+// destructuring
+const { name, age, ...rest } = person;
+const [ x, y, ...rest ] = arr;
+
+// template literals
+${'console.log(`The sum of ${a} and ${b} is ${sum(a, b)}.`);'}
+`.trim();

package/src/data/questions.js

@@ -0,0 +1,11 @@
+import * as fields from './fields.js';
+
+export function *questions({ rows, ...options } = {}) {
+  for (let i = 0; i < rows; i++) {
+    yield question({ ...options, index: i });
+  }
+}
+
+function question({} = {}) {
+  return fields.description({ size: [4, 8], punctuation: '?' });
+}

package/src/data/utils.js

@@ -1,3 +1,7 @@
+export function uuid() {
+  return ([1e7]+-1e3+-4e3+-8e3+-1e11).replace(/[018]/g, a => (a ^ Math.random() * 16 >> a / 4).toString(16));
+}
+
 export function randomInt(min, max) {
   return max == null || (max <= min) ? min : (min + Math.floor(Math.random() * (max - min)));
 }
@@ -29,3 +33,20 @@ export function imageUrl(size) {
   const sizePath = Array.isArray(size) ? size.length > 1 ? `${size[0]}/${size[1]}` : `${size[0]}` : `${size}`;
   return `https://picsum.photos/seed/${seed}/${sizePath}`;
 }
+
+export function formatDatetime(timestamp) {
+  const str = new Date(timestamp).toISOString();
+  return str.endsWith('Z') ? str.slice(0, -1) : str;
+}
+
+export function sample(size, sampling) {
+  return sampling !== undefined ? Math.ceil(size * sampling) : size;
+}
+
+export function gaussRandom() {
+  return uniformRandom() + uniformRandom() + uniformRandom();
+}
+
+function uniformRandom() {
+  return Math.random() * 2 - 1;
+}

package/src/data/words.js

@@ -0,0 +1,182 @@
+
+// genereated by bin/data.js
+export default [
+  "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/doggoganger.js

@@ -0,0 +1,54 @@
+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 _route from './route/index.js';
+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 = _route(new Api(options), options);
+  
+  router.use('/api', api.routes(), api.allowedMethods());
+  router.use('/v1', api.routes(), api.allowedMethods());
+
+  if (serve) {
+    app
+      .use(exclusion)
+      .use(serveStatic('.'));
+  }
+
+  app
+    .use(cors())
+    .use(koaBody({
+      formLimit: '100mb',
+      textLimit: '100mb',
+      jsonLimit: '100mb',
+      onerror: function (err, ctx) {
+        console.error(err);
+        ctx.throw('body parse error', 422);
+      },
+    }))
+    .use(handleAllPath(options))
+    .use(router.routes())
+    .use(router.allowedMethods())
+    .use(handleUnrecognizedPath(options))
+    .listen(port);
+}
+
+function handleAllPath({ verbose } = {}) {
+  return async (ctx, next) => {
+    verbose && console.log(`${ctx.method} ${ctx.url}`);
+    await next();
+  };
+}
+
+function handleUnrecognizedPath({ verbose } = {}) {
+  return async (ctx, next) => {
+    verbose && console.log(`Unrecognized path: ${ctx.method} ${ctx.url}`);
+    await next();
+  };
+}

package/src/index.js

@@ -1,28 +1,3 @@
-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);
-}
+export { default as doggoganger } from './doggoganger.js';
+export { default as buildApi } from './browser.js';
+export { default as buildRouter } from './route/index.js';

package/src/middleware/error.js

@@ -0,0 +1,29 @@
+import { trimObj } from '../utils.js';
+
+const DEFAULT_OPTIONS = {
+  rate: 0,
+  verbose: false,
+};
+
+export default function error(options) {
+  const globalOptions = {
+    ...DEFAULT_OPTIONS,
+    ...trimObj(options),
+  };
+  return async (ctx, next) => {
+    const { rate, verbose } = {
+      ...globalOptions, 
+      ...getOptionsFromCtx(ctx),
+    };
+    if (rate && Math.random() < rate) {
+      verbose && console.log(`Simulate error`);
+      throw new Error();
+    }
+    await next();
+  };
+}
+
+function getOptionsFromCtx(ctx) {
+  const rate = Number(ctx.get('x-error-rate')) || undefined;
+  return trimObj({ rate });
+}

package/src/middleware/index.js

@@ -0,0 +1,2 @@
+export { default as latency } from './latency.js';
+export { default as error } from './error.js';

package/src/middleware/latency.js

@@ -0,0 +1,39 @@
+import { delay, trimObj } from '../utils.js';
+import { gaussRandom } from '../data/utils.js';
+
+const DEFAULT_OPTIONS = {
+  enabled: true,
+  verbose: false,
+  min: 200,
+  max: 2000,
+};
+
+export default function latency(options) {
+  const globalOptions = {
+    ...DEFAULT_OPTIONS,
+    ...trimObj(options),
+  };
+  return async (ctx, next) => {
+    const { enabled, min, max, verbose } = {
+      ...globalOptions, 
+      ...getOptionsFromCtx(ctx),
+    };
+    if (enabled) {
+      const time = (min + max) / 2 + gaussRandom() * (max - min) / 6;
+      verbose && console.log(`Add latency: ${time}ms`);
+      await delay(time);
+    }
+    await next();
+  };
+}
+
+function getOptionsFromCtx(ctx) {
+  const latencyStr = ctx.get('x-latency') || undefined;
+  if (latencyStr === '0' || latencyStr === 'false') {
+    return { enabled: false };
+  }
+  const value = Number(latencyStr) || undefined;
+  const min = value || Number(ctx.get('x-latency-min')) || undefined;
+  const max = value || Number(ctx.get('x-latency-max')) || undefined;
+  return trimObj({ min, max });
+}

package/src/route/ask.js

@@ -0,0 +1,37 @@
+import Router from '@koa/router';
+import { parseBodyIfNecessary } from './utils.js';
+
+function getOptionsFromCtx(ctx) {
+  const speedRate = Number(ctx.get('x-speed-rate')) || undefined;
+  const answerFormat = ctx.get('x-answer-format') || undefined;
+  const answerSampling = Number(ctx.get('x-answer-sampling')) || undefined;
+  const answerLanguagesStr = ctx.get('x-answer-languages') || undefined;
+  const answerLanguages = answerLanguagesStr ? answerLanguagesStr.split(',') : undefined;
+  return { answerFormat, answerSampling, answerLanguages, speedRate };
+}
+
+export default function(api) {
+  const answers = new Map();
+  const router = new Router();
+
+  router.post('/questions', (ctx) => {
+    const { question, parent_question_id } = parseBodyIfNecessary(ctx.request.body);
+    const answer = api.ask.questions({ question, parent_question_id }, getOptionsFromCtx(ctx));
+    const { question_id } = answer;
+    answers.set(question_id, answer);
+    ctx.body = JSON.stringify({ data: { question_id } });
+  });
+
+  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;
+}