gitsheets 0.22.4 → 1.0.3

package/lib/path/FieldComponent.js

@@ -1,13 +0,0 @@
-class FieldComponent extends require('./BaseComponent.js') {
-  constructor ({ recursive = false }) {
-    super(...arguments);
-    this.recursive = recursive;
-    Object.freeze(this);
-  }
-
-  render (record) {
-    return this.formatValue(record ? record[this.name] : undefined);
-  }
-}
-
-module.exports = FieldComponent;

package/lib/path/LiteralComponent.js

@@ -1,12 +0,0 @@
-class LiteralComponent extends require('./BaseComponent.js') {
-  constructor () {
-    super(...arguments);
-    Object.freeze(this);
-  }
-
-  render (record) {
-    return this.formatValue(this.name);
-  }
-}
-
-module.exports = LiteralComponent;

package/lib/path/Query.js

@@ -1,18 +0,0 @@
-class Query {
-  prefix;
-  complete;
-
-  static render (template, query) {
-    debugger;
-
-    return new this();
-  }
-
-  constructor (prefix, complete) {
-    this.prefix = prefix;
-    this.complete = complete;
-    Object.freeze(this);
-  }
-}
-
-module.exports = Query;

package/lib/path/Template.js

@@ -1,214 +0,0 @@
-const path = require('path');
-const LiteralComponent = require('./LiteralComponent.js');
-const FieldComponent = require('./FieldComponent.js');
-const ExpressionComponent = require('./ExpressionComponent.js');
-// const Query = require('./Query.js');
-
-const FIELD_EXPRESSION_RE = /^[a-zA-Z0-9_\-]+(\/\*\*)?$/;
-const INSTANCE_CACHE = new Map();
-const PATH_COMPONENT_TEMPLATE = {
-  kind: LiteralComponent,
-  prefix: '',
-  name: '',
-  suffix: '',
-};
-
-class Template
-{
-  static fromString (templateString) {
-    let instance = INSTANCE_CACHE.get(templateString);
-
-    if (instance) {
-      return instance;
-    }
-
-    instance = new this(parseRecordPathTemplate(templateString));
-    INSTANCE_CACHE.set(templateString, instance);
-
-    return instance;
-  }
-
-  #components;
-
-  constructor (templateComponents) {
-    this.#components = templateComponents;
-  }
-
-  render (record) {
-    const recordPath = [];
-
-    for (const component of this.#components) {
-      const string = component.render(record);
-
-      if (string === null) {
-        throw new Error('unable to render path component');
-      }
-
-      recordPath.push(string);
-    }
-
-    return recordPath.join('/');
-  }
-
-  async* queryTree (tree, query, pathPrefix = '', depth = 0) {
-    const numComponents = this.#components.length;
-
-    if (!tree) {
-      // no results if tree doesn't exist
-      return;
-    }
-
-    for (let i = depth, currentTree = tree; i < numComponents; i++) {
-      const isLast = i +1 == numComponents;
-      const cur = this.#components[i];
-      const nextName = cur.render(query);
-
-      if (isLast) {
-        if (nextName) {
-          const child = await currentTree.getChild(`${nextName}.toml`);
-
-          if (child) {
-            yield { path: path.join(pathPrefix, nextName), blob: child };
-          }
-
-          // absolute match on a leaf, we're done with this query
-          return;
-        } else {
-          // each record in current tree is a result
-          const children = cur.recursive
-            ? await currentTree.getBlobMap()
-            : await currentTree.getChildren();
-
-          let attachmentsPrefix;
-
-          for (const childPath in children) {
-            if (!childPath.endsWith('.toml')) {
-              continue;
-            }
-
-            if (attachmentsPrefix && childPath.indexOf(attachmentsPrefix) === 0) {
-              // this file is an attachment under the previous record
-              continue;
-            }
-
-            const child = children[childPath];
-
-            if (!child || !child.isBlob) {
-              continue;
-            }
-
-            const childName = childPath.substr(0, childPath.length - 5);
-            attachmentsPrefix = `${childName}/`;
-            yield { path: path.join(pathPrefix, childName), blob: child };
-          }
-
-          return;
-        }
-      }
-
-      // crawl down the tree
-      if (nextName) {
-        const nextTree = await currentTree.getChild(nextName);
-
-        if (nextTree) {
-          currentTree = nextTree;
-          pathPrefix = path.join(pathPrefix, nextName);
-        } else {
-          return;
-        }
-      } else {
-        // each tree in current tree could contain matching records
-        const children = await currentTree.getChildren();
-        for (const childPath in children) {
-          const child = children[childPath];
-
-          if (!child.isTree) {
-            continue;
-          }
-
-          yield* this.queryTree(child, query, path.join(pathPrefix, childPath), i+1);
-        }
-
-        return;
-      }
-    }
-  }
-}
-
-module.exports = Template;
-
-
-// private library
-function parseRecordPathTemplate(templateString) {
-  templateString = path.join('.', templateString, '.');
-  const stringLength = templateString.length;
-
-
-  let i = 0, cur = { ...PATH_COMPONENT_TEMPLATE };
-
-
-  const parsed = [];
-  const finishCurrentComponent = () => {
-    if (cur.name) {
-      parsed.push(new cur.kind(cur));
-    }
-    cur = { ...PATH_COMPONENT_TEMPLATE };
-  };
-
-
-  while (i < stringLength) {
-    const nextChar = templateString[i];
-
-    // read an expression from ${{ to }}
-    if (nextChar == '$' && templateString.substr(i, 3) == '${{') {
-      cur.kind = ExpressionComponent;
-      i += 3;
-
-      if (cur.name) {
-        cur.prefix = cur.name;
-        cur.name = '';
-      }
-
-      while (templateString.substr(i, 2) != '}}') {
-        cur.name += templateString[i];
-        i++;
-
-        if (i == stringLength) {
-          throw new Error(`expression ${cur.name} not closed with }}`);
-        }
-      }
-
-      // finish reading name expression
-      cur.name = cur.name.trim();
-
-      // reduce to Field kind if name is a bare field name
-      if (FIELD_EXPRESSION_RE.test(cur.name)) {
-        cur.kind = FieldComponent;
-
-        if (cur.name.endsWith('/**')) {
-          cur.recursive = true;
-          cur.name = cur.name.substr(0, cur.name.length - 3);
-        }
-      }
-
-      // skip }} and continue scan from the top
-      i += 2;
-      continue;
-    }
-
-    // process next character
-    if (nextChar == '/') {
-      finishCurrentComponent();
-    } else if (cur.kind !== LiteralComponent) {
-      cur.suffix += nextChar;
-    } else {
-      cur.name += nextChar;
-    }
-
-    i++;
-  }
-
-  finishCurrentComponent();
-
-  return parsed;
-}

package/server.js

@@ -1,120 +0,0 @@
-const Koa = require('koa')
-const Router = require('koa-router')
-const bodyParser = require('koa-bodyparser')
-const { format: csvFormat } = require('fast-csv')
-const JsonStringify = require('streaming-json-stringify')
-const GitSheets = require('./lib/GitSheets')
-
-const validRefPattern = /^[\w-\/]+$/
-const validPathTemplatePattern = /^[{}\w- \/]+$/
-
-module.exports = createServer
-
-if (!module.parent) {
-  GitSheets.create()
-    .then(createServer)
-    .then((app) => {
-      app.listen(3000)
-    })
-}
-
-async function createServer (gitSheets) {
-  const app = new Koa()
-  const router = new Router()
-
-  router.get('/config/:ref+', async (ctx) => {
-    const ref = ctx.params.ref
-    ctx.assert(validRefPattern.test(ref), 400, 'invalid ref')
-
-    const config = await gitSheets.getConfig(ref)
-    ctx.body = { config }
-  })
-
-  router.put('/config/:ref+', bodyParser(), async (ctx) => {
-    const ref = ctx.params.ref
-    const { path } = ctx.request.body.config
-    const config = { path }
-
-    ctx.assert(validRefPattern.test(ref), 400, 'invalid ref')
-    ctx.assert(validPathTemplatePattern.test(path), 400, 'invalid path template')
-
-    await gitSheets.setConfig(ref, config)
-    ctx.status = 204
-  })
-
-  router.get('/records/:ref+', async (ctx) => {
-    const ref = ctx.params.ref
-    const format = ctx.query.format
-    ctx.assert(validRefPattern.test(ref), 400, 'invalid ref')
-
-    const rows = await gitSheets.export(ref)
-
-    switch (format || ctx.accepts('json', 'csv')) {
-      case 'csv':
-        ctx.type = 'text/csv'
-        ctx.set('Content-Disposition', `attachment; filename=${ref}.csv`)
-        ctx.body = rows.pipe(csvFormat({ headers: true }))
-        break
-      default:
-        ctx.type = 'application/json'
-        ctx.body = rows.pipe(JsonStringify())
-    }
-  })
-
-  router.post('/import/:ref+', async (ctx) => {
-    const ref = ctx.params.ref
-    const readStream = ctx.req
-    const branch = ctx.request.query.branch || ref
-
-    ctx.assert(ctx.is('csv'), 415, 'content-type must be text/csv')
-    ctx.assert(validRefPattern.test(ref), 400, 'invalid ref')
-
-    await gitSheets.import({
-      data: readStream,
-      dataType: 'csv',
-      parentRef: ref,
-      saveToBranch: branch
-    })
-    ctx.status = 204
-  })
-
-  router.get('/compare/:srcRef([\\w-\\/]+)..:dstRef([\\w-\\/]+)', async (ctx) => {
-    const { srcRef, dstRef } = ctx.params
-
-    ctx.assert(validRefPattern.test(srcRef), 400, 'invalid src ref')
-    ctx.assert(validRefPattern.test(dstRef), 400, 'invalid dst ref')
-
-    const diffs = await gitSheets.compare(srcRef, dstRef)
-    ctx.body = diffs
-  })
-
-  router.post('/compare/:srcRef([\\w-\\/]+)..:dstRef([\\w-\\/]+)', async (ctx) => {
-    const { srcRef, dstRef } = ctx.params
-    const msg = ctx.query.msg
-
-    ctx.assert(validRefPattern.test(srcRef), 400, 'invalid src ref')
-    ctx.assert(validRefPattern.test(dstRef), 400, 'invalid dst ref')
-
-    await gitSheets.merge(srcRef, dstRef, msg)
-    ctx.status = 204
-  })
-
-  async function errorHandler (ctx, next) {
-    try {
-      await next()
-    } catch (err) {
-      if (err.status) {
-        ctx.status = err.status
-        ctx.body = { message: err.message, code: err.constructor.name }
-      } else {
-        ctx.status = 500
-        ctx.body = { message: 'An unexpected error occurred' }
-      }
-    }
-  }
-
-  return app
-    .use(errorHandler)
-    .use(router.routes())
-    .use(router.allowedMethods())
-}