orcaq 1.0.26 → 1.0.28

package/.output/server/node_modules/knex/lib/dialects/sqlite3/schema/internal/parser.js

@@ -0,0 +1,638 @@
+const { tokenize } = require('./tokenizer');
+const { s, a, m, o, l, n, t, e, f } = require('./parser-combinator');
+
+const TOKENS = {
+  keyword:
+    /(?:ABORT|ACTION|ADD|AFTER|ALL|ALTER|ALWAYS|ANALYZE|AND|AS|ASC|ATTACH|AUTOINCREMENT|BEFORE|BEGIN|BETWEEN|BY|CASCADE|CASE|CAST|CHECK|COLLATE|COLUMN|COMMIT|CONFLICT|CONSTRAINT|CREATE|CROSS|CURRENT|CURRENT_DATE|CURRENT_TIME|CURRENT_TIMESTAMP|DATABASE|DEFAULT|DEFERRED|DEFERRABLE|DELETE|DESC|DETACH|DISTINCT|DO|DROP|END|EACH|ELSE|ESCAPE|EXCEPT|EXCLUSIVE|EXCLUDE|EXISTS|EXPLAIN|FAIL|FILTER|FIRST|FOLLOWING|FOR|FOREIGN|FROM|FULL|GENERATED|GLOB|GROUP|GROUPS|HAVING|IF|IGNORE|IMMEDIATE|IN|INDEX|INDEXED|INITIALLY|INNER|INSERT|INSTEAD|INTERSECT|INTO|IS|ISNULL|JOIN|KEY|LAST|LEFT|LIKE|LIMIT|MATCH|MATERIALIZED|NATURAL|NO|NOT|NOTHING|NOTNULL|NULL|NULLS|OF|OFFSET|ON|OR|ORDER|OTHERS|OUTER|OVER|PARTITION|PLAN|PRAGMA|PRECEDING|PRIMARY|QUERY|RAISE|RANGE|RECURSIVE|REFERENCES|REGEXP|REINDEX|RELEASE|RENAME|REPLACE|RESTRICT|RETURNING|RIGHT|ROLLBACK|ROW|ROWS|SAVEPOINT|SELECT|SET|TABLE|TEMP|TEMPORARY|THEN|TIES|TO|TRANSACTION|TRIGGER|UNBOUNDED|UNION|UNIQUE|UPDATE|USING|VACUUM|VALUES|VIEW|VIRTUAL|WHEN|WHERE|WINDOW|WITH|WITHOUT)(?=\s+|-|\(|\)|;|\+|\*|\/|%|==|=|<=|<>|<<|<|>=|>>|>|!=|,|&|~|\|\||\||\.)/,
+  id: /"[^"]*(?:""[^"]*)*"|`[^`]*(?:``[^`]*)*`|\[[^[\]]*\]|[a-z_][a-z0-9_$]*/,
+  string: /'[^']*(?:''[^']*)*'/,
+  blob: /x'(?:[0-9a-f][0-9a-f])+'/,
+  numeric: /(?:\d+(?:\.\d*)?|\.\d+)(?:e(?:\+|-)?\d+)?|0x[0-9a-f]+/,
+  variable: /\?\d*|[@$:][a-z0-9_$]+/,
+  operator: /-|\(|\)|;|\+|\*|\/|%|==|=|<=|<>|<<|<|>=|>>|>|!=|,|&|~|\|\||\||\./,
+  _ws: /\s+/,
+};
+
+function parseCreateTable(sql) {
+  const result = createTable({ input: tokenize(sql, TOKENS) });
+
+  if (!result.success) {
+    throw new Error(
+      `Parsing CREATE TABLE failed at [${result.input
+        .slice(result.index)
+        .map((t) => t.text)
+        .join(' ')}] of "${sql}"`
+    );
+  }
+
+  return result.ast;
+}
+
+function parseCreateIndex(sql) {
+  const result = createIndex({ input: tokenize(sql, TOKENS) });
+
+  if (!result.success) {
+    throw new Error(
+      `Parsing CREATE INDEX failed at [${result.input
+        .slice(result.index)
+        .map((t) => t.text)
+        .join(' ')}] of "${sql}"`
+    );
+  }
+
+  return result.ast;
+}
+
+function createTable(ctx) {
+  return s(
+    [
+      t({ text: 'CREATE' }, (v) => null),
+      temporary,
+      t({ text: 'TABLE' }, (v) => null),
+      exists,
+      schema,
+      table,
+      t({ text: '(' }, (v) => null),
+      columnDefinitionList,
+      tableConstraintList,
+      t({ text: ')' }, (v) => null),
+      rowid,
+      f,
+    ],
+    (v) => Object.assign({}, ...v.filter((x) => x !== null))
+  )(ctx);
+}
+
+function temporary(ctx) {
+  return a([t({ text: 'TEMP' }), t({ text: 'TEMPORARY' }), e], (v) => ({
+    temporary: v !== null,
+  }))(ctx);
+}
+
+function rowid(ctx) {
+  return o(s([t({ text: 'WITHOUT' }), t({ text: 'ROWID' })]), (v) => ({
+    rowid: v !== null,
+  }))(ctx);
+}
+
+function columnDefinitionList(ctx) {
+  return a([
+    s([columnDefinition, t({ text: ',' }), columnDefinitionList], (v) => ({
+      columns: [v[0]].concat(v[2].columns),
+    })),
+    s([columnDefinition], (v) => ({ columns: [v[0]] })),
+  ])(ctx);
+}
+
+function columnDefinition(ctx) {
+  return s(
+    [s([identifier], (v) => ({ name: v[0] })), typeName, columnConstraintList],
+    (v) => Object.assign({}, ...v)
+  )(ctx);
+}
+
+function typeName(ctx) {
+  return o(
+    s(
+      [
+        m(t({ type: 'id' })),
+        a([
+          s(
+            [
+              t({ text: '(' }),
+              signedNumber,
+              t({ text: ',' }),
+              signedNumber,
+              t({ text: ')' }),
+            ],
+            (v) => `(${v[1]}, ${v[3]})`
+          ),
+          s(
+            [t({ text: '(' }), signedNumber, t({ text: ')' })],
+            (v) => `(${v[1]})`
+          ),
+          e,
+        ]),
+      ],
+      (v) => `${v[0].join(' ')}${v[1] || ''}`
+    ),
+    (v) => ({ type: v })
+  )(ctx);
+}
+
+function columnConstraintList(ctx) {
+  return o(m(columnConstraint), (v) => ({
+    constraints: Object.assign(
+      {
+        primary: null,
+        notnull: null,
+        null: null,
+        unique: null,
+        check: null,
+        default: null,
+        collate: null,
+        references: null,
+        as: null,
+      },
+      ...(v || [])
+    ),
+  }))(ctx);
+}
+
+function columnConstraint(ctx) {
+  return a([
+    primaryColumnConstraint,
+    notnullColumnConstraint,
+    nullColumnConstraint,
+    uniqueColumnConstraint,
+    checkColumnConstraint,
+    defaultColumnConstraint,
+    collateColumnConstraint,
+    referencesColumnConstraint,
+    asColumnConstraint,
+  ])(ctx);
+}
+
+function primaryColumnConstraint(ctx) {
+  return s(
+    [
+      constraintName,
+      t({ text: 'PRIMARY' }, (v) => null),
+      t({ text: 'KEY' }, (v) => null),
+      order,
+      conflictClause,
+      autoincrement,
+    ],
+    (v) => ({ primary: Object.assign({}, ...v.filter((x) => x !== null)) })
+  )(ctx);
+}
+
+function autoincrement(ctx) {
+  return o(t({ text: 'AUTOINCREMENT' }), (v) => ({
+    autoincrement: v !== null,
+  }))(ctx);
+}
+
+function notnullColumnConstraint(ctx) {
+  return s(
+    [
+      constraintName,
+      t({ text: 'NOT' }, (v) => null),
+      t({ text: 'NULL' }, (v) => null),
+      conflictClause,
+    ],
+    (v) => ({ notnull: Object.assign({}, ...v.filter((x) => x !== null)) })
+  )(ctx);
+}
+
+function nullColumnConstraint(ctx) {
+  return s(
+    [constraintName, t({ text: 'NULL' }, (v) => null), conflictClause],
+    (v) => ({ null: Object.assign({}, ...v.filter((x) => x !== null)) })
+  )(ctx);
+}
+
+function uniqueColumnConstraint(ctx) {
+  return s(
+    [constraintName, t({ text: 'UNIQUE' }, (v) => null), conflictClause],
+    (v) => ({ unique: Object.assign({}, ...v.filter((x) => x !== null)) })
+  )(ctx);
+}
+
+function checkColumnConstraint(ctx) {
+  return s(
+    [
+      constraintName,
+      t({ text: 'CHECK' }, (v) => null),
+      t({ text: '(' }, (v) => null),
+      s([expression], (v) => ({ expression: v[0] })),
+      t({ text: ')' }, (v) => null),
+    ],
+    (v) => ({ check: Object.assign({}, ...v.filter((x) => x !== null)) })
+  )(ctx);
+}
+
+function defaultColumnConstraint(ctx) {
+  return s(
+    [
+      constraintName,
+      t({ text: 'DEFAULT' }, (v) => null),
+      a([
+        s([t({ text: '(' }), expression, t({ text: ')' })], (v) => ({
+          value: v[1],
+          expression: true,
+        })),
+        s([literalValue], (v) => ({ value: v[0], expression: false })),
+        s([signedNumber], (v) => ({ value: v[0], expression: false })),
+      ]),
+    ],
+    (v) => ({ default: Object.assign({}, ...v.filter((x) => x !== null)) })
+  )(ctx);
+}
+
+function collateColumnConstraint(ctx) {
+  return s(
+    [
+      constraintName,
+      t({ text: 'COLLATE' }, (v) => null),
+      t({ type: 'id' }, (v) => ({ collation: v.text })),
+    ],
+    (v) => ({ collate: Object.assign({}, ...v.filter((x) => x !== null)) })
+  )(ctx);
+}
+
+function referencesColumnConstraint(ctx) {
+  return s(
+    [constraintName, s([foreignKeyClause], (v) => v[0].references)],
+    (v) => ({
+      references: Object.assign({}, ...v.filter((x) => x !== null)),
+    })
+  )(ctx);
+}
+
+function asColumnConstraint(ctx) {
+  return s(
+    [
+      constraintName,
+      o(s([t({ text: 'GENERATED' }), t({ text: 'ALWAYS' })]), (v) => ({
+        generated: v !== null,
+      })),
+      t({ text: 'AS' }, (v) => null),
+      t({ text: '(' }, (v) => null),
+      s([expression], (v) => ({ expression: v[0] })),
+      t({ text: ')' }, (v) => null),
+      a([t({ text: 'STORED' }), t({ text: 'VIRTUAL' }), e], (v) => ({
+        mode: v ? v.toUpperCase() : null,
+      })),
+    ],
+    (v) => ({ as: Object.assign({}, ...v.filter((x) => x !== null)) })
+  )(ctx);
+}
+
+function tableConstraintList(ctx) {
+  return o(m(s([t({ text: ',' }), tableConstraint], (v) => v[1])), (v) => ({
+    constraints: v || [],
+  }))(ctx);
+}
+
+function tableConstraint(ctx) {
+  return a([
+    primaryTableConstraint,
+    uniqueTableConstraint,
+    checkTableConstraint,
+    foreignTableConstraint,
+  ])(ctx);
+}
+
+function primaryTableConstraint(ctx) {
+  return s(
+    [
+      constraintName,
+      t({ text: 'PRIMARY' }, (v) => null),
+      t({ text: 'KEY' }, (v) => null),
+      t({ text: '(' }, (v) => null),
+      indexedColumnList,
+      t({ text: ')' }, (v) => null),
+      conflictClause,
+    ],
+    (v) =>
+      Object.assign({ type: 'PRIMARY KEY' }, ...v.filter((x) => x !== null))
+  )(ctx);
+}
+
+function uniqueTableConstraint(ctx) {
+  return s(
+    [
+      constraintName,
+      t({ text: 'UNIQUE' }, (v) => null),
+      t({ text: '(' }, (v) => null),
+      indexedColumnList,
+      t({ text: ')' }, (v) => null),
+      conflictClause,
+    ],
+    (v) => Object.assign({ type: 'UNIQUE' }, ...v.filter((x) => x !== null))
+  )(ctx);
+}
+
+function conflictClause(ctx) {
+  return o(
+    s(
+      [
+        t({ text: 'ON' }),
+        t({ text: 'CONFLICT' }),
+        a([
+          t({ text: 'ROLLBACK' }),
+          t({ text: 'ABORT' }),
+          t({ text: 'FAIL' }),
+          t({ text: 'IGNORE' }),
+          t({ text: 'REPLACE' }),
+        ]),
+      ],
+      (v) => v[2]
+    ),
+    (v) => ({ conflict: v ? v.toUpperCase() : null })
+  )(ctx);
+}
+
+function checkTableConstraint(ctx) {
+  return s(
+    [
+      constraintName,
+      t({ text: 'CHECK' }, (v) => null),
+      t({ text: '(' }, (v) => null),
+      s([expression], (v) => ({ expression: v[0] })),
+      t({ text: ')' }, (v) => null),
+    ],
+    (v) => Object.assign({ type: 'CHECK' }, ...v.filter((x) => x !== null))
+  )(ctx);
+}
+
+function foreignTableConstraint(ctx) {
+  return s(
+    [
+      constraintName,
+      t({ text: 'FOREIGN' }, (v) => null),
+      t({ text: 'KEY' }, (v) => null),
+      t({ text: '(' }, (v) => null),
+      columnNameList,
+      t({ text: ')' }, (v) => null),
+      foreignKeyClause,
+    ],
+    (v) =>
+      Object.assign({ type: 'FOREIGN KEY' }, ...v.filter((x) => x !== null))
+  )(ctx);
+}
+
+function foreignKeyClause(ctx) {
+  return s(
+    [
+      t({ text: 'REFERENCES' }, (v) => null),
+      table,
+      columnNameListOptional,
+      o(m(a([deleteReference, updateReference, matchReference])), (v) =>
+        Object.assign({ delete: null, update: null, match: null }, ...(v || []))
+      ),
+      deferrable,
+    ],
+    (v) => ({ references: Object.assign({}, ...v.filter((x) => x !== null)) })
+  )(ctx);
+}
+
+function columnNameListOptional(ctx) {
+  return o(
+    s([t({ text: '(' }), columnNameList, t({ text: ')' })], (v) => v[1]),
+    (v) => ({ columns: v ? v.columns : [] })
+  )(ctx);
+}
+
+function columnNameList(ctx) {
+  return s(
+    [
+      o(m(s([identifier, t({ text: ',' })], (v) => v[0])), (v) =>
+        v !== null ? v : []
+      ),
+      identifier,
+    ],
+    (v) => ({ columns: v[0].concat([v[1]]) })
+  )(ctx);
+}
+
+function deleteReference(ctx) {
+  return s([t({ text: 'ON' }), t({ text: 'DELETE' }), onAction], (v) => ({
+    delete: v[2],
+  }))(ctx);
+}
+
+function updateReference(ctx) {
+  return s([t({ text: 'ON' }), t({ text: 'UPDATE' }), onAction], (v) => ({
+    update: v[2],
+  }))(ctx);
+}
+
+function matchReference(ctx) {
+  return s(
+    [t({ text: 'MATCH' }), a([t({ type: 'keyword' }), t({ type: 'id' })])],
+    (v) => ({ match: v[1] })
+  )(ctx);
+}
+
+function deferrable(ctx) {
+  return o(
+    s([
+      o(t({ text: 'NOT' })),
+      t({ text: 'DEFERRABLE' }),
+      o(
+        s(
+          [
+            t({ text: 'INITIALLY' }),
+            a([t({ text: 'DEFERRED' }), t({ text: 'IMMEDIATE' })]),
+          ],
+          (v) => v[1].toUpperCase()
+        )
+      ),
+    ]),
+    (v) => ({ deferrable: v ? { not: v[0] !== null, initially: v[2] } : null })
+  )(ctx);
+}
+
+function constraintName(ctx) {
+  return o(
+    s([t({ text: 'CONSTRAINT' }), identifier], (v) => v[1]),
+    (v) => ({ name: v })
+  )(ctx);
+}
+
+function createIndex(ctx) {
+  return s(
+    [
+      t({ text: 'CREATE' }, (v) => null),
+      unique,
+      t({ text: 'INDEX' }, (v) => null),
+      exists,
+      schema,
+      index,
+      t({ text: 'ON' }, (v) => null),
+      table,
+      t({ text: '(' }, (v) => null),
+      indexedColumnList,
+      t({ text: ')' }, (v) => null),
+      where,
+      f,
+    ],
+    (v) => Object.assign({}, ...v.filter((x) => x !== null))
+  )(ctx);
+}
+
+function unique(ctx) {
+  return o(t({ text: 'UNIQUE' }), (v) => ({ unique: v !== null }))(ctx);
+}
+
+function exists(ctx) {
+  return o(
+    s([t({ text: 'IF' }), t({ text: 'NOT' }), t({ text: 'EXISTS' })]),
+    (v) => ({ exists: v !== null })
+  )(ctx);
+}
+
+function schema(ctx) {
+  return o(
+    s([identifier, t({ text: '.' })], (v) => v[0]),
+    (v) => ({ schema: v })
+  )(ctx);
+}
+
+function index(ctx) {
+  return s([identifier], (v) => ({ index: v[0] }))(ctx);
+}
+
+function table(ctx) {
+  return s([identifier], (v) => ({ table: v[0] }))(ctx);
+}
+
+function where(ctx) {
+  return o(
+    s([t({ text: 'WHERE' }), expression], (v) => v[1]),
+    (v) => ({ where: v })
+  )(ctx);
+}
+
+function indexedColumnList(ctx) {
+  return a([
+    s([indexedColumn, t({ text: ',' }), indexedColumnList], (v) => ({
+      columns: [v[0]].concat(v[2].columns),
+    })),
+    s([indexedColumnExpression, t({ text: ',' }), indexedColumnList], (v) => ({
+      columns: [v[0]].concat(v[2].columns),
+    })),
+    l({ do: indexedColumn, next: t({ text: ')' }) }, (v) => ({
+      columns: [v],
+    })),
+    l({ do: indexedColumnExpression, next: t({ text: ')' }) }, (v) => ({
+      columns: [v],
+    })),
+  ])(ctx);
+}
+
+function indexedColumn(ctx) {
+  return s(
+    [
+      s([identifier], (v) => ({ name: v[0], expression: false })),
+      collation,
+      order,
+    ],
+    (v) => Object.assign({}, ...v.filter((x) => x !== null))
+  )(ctx);
+}
+
+function indexedColumnExpression(ctx) {
+  return s(
+    [
+      s([indexedExpression], (v) => ({ name: v[0], expression: true })),
+      collation,
+      order,
+    ],
+    (v) => Object.assign({}, ...v.filter((x) => x !== null))
+  )(ctx);
+}
+
+function collation(ctx) {
+  return o(
+    s([t({ text: 'COLLATE' }), t({ type: 'id' })], (v) => v[1]),
+    (v) => ({ collation: v })
+  )(ctx);
+}
+
+function order(ctx) {
+  return a([t({ text: 'ASC' }), t({ text: 'DESC' }), e], (v) => ({
+    order: v ? v.toUpperCase() : null,
+  }))(ctx);
+}
+
+function indexedExpression(ctx) {
+  return m(
+    a([
+      n({
+        do: t({ type: 'keyword' }),
+        not: a([
+          t({ text: 'COLLATE' }),
+          t({ text: 'ASC' }),
+          t({ text: 'DESC' }),
+        ]),
+      }),
+      t({ type: 'id' }),
+      t({ type: 'string' }),
+      t({ type: 'blob' }),
+      t({ type: 'numeric' }),
+      t({ type: 'variable' }),
+      n({
+        do: t({ type: 'operator' }),
+        not: a([t({ text: '(' }), t({ text: ')' }), t({ text: ',' })]),
+      }),
+      s([t({ text: '(' }), o(expression), t({ text: ')' })], (v) => v[1] || []),
+    ])
+  )(ctx);
+}
+
+function expression(ctx) {
+  return m(
+    a([
+      t({ type: 'keyword' }),
+      t({ type: 'id' }),
+      t({ type: 'string' }),
+      t({ type: 'blob' }),
+      t({ type: 'numeric' }),
+      t({ type: 'variable' }),
+      n({
+        do: t({ type: 'operator' }),
+        not: a([t({ text: '(' }), t({ text: ')' })]),
+      }),
+      s([t({ text: '(' }), o(expression), t({ text: ')' })], (v) => v[1] || []),
+    ])
+  )(ctx);
+}
+
+function identifier(ctx) {
+  return a([t({ type: 'id' }), t({ type: 'string' })], (v) =>
+    /^["`['][^]*["`\]']$/.test(v) ? v.substring(1, v.length - 1) : v
+  )(ctx);
+}
+
+function onAction(ctx) {
+  return a(
+    [
+      s([t({ text: 'SET' }), t({ text: 'NULL' })], (v) => `${v[0]} ${v[1]}`),
+      s([t({ text: 'SET' }), t({ text: 'DEFAULT' })], (v) => `${v[0]} ${v[1]}`),
+      t({ text: 'CASCADE' }),
+      t({ text: 'RESTRICT' }),
+      s([t({ text: 'NO' }), t({ text: 'ACTION' })], (v) => `${v[0]} ${v[1]}`),
+    ],
+    (v) => v.toUpperCase()
+  )(ctx);
+}
+
+function literalValue(ctx) {
+  return a([
+    t({ type: 'numeric' }),
+    t({ type: 'string' }),
+    t({ type: 'id' }),
+    t({ type: 'blob' }),
+    t({ text: 'NULL' }),
+    t({ text: 'TRUE' }),
+    t({ text: 'FALSE' }),
+    t({ text: 'CURRENT_TIME' }),
+    t({ text: 'CURRENT_DATE' }),
+    t({ text: 'CURRENT_TIMESTAMP' }),
+  ])(ctx);
+}
+
+function signedNumber(ctx) {
+  return s(
+    [a([t({ text: '+' }), t({ text: '-' }), e]), t({ type: 'numeric' })],
+    (v) => `${v[0] || ''}${v[1]}`
+  )(ctx);
+}
+
+module.exports = {
+  parseCreateTable,
+  parseCreateIndex,
+};

package/.output/server/node_modules/knex/lib/dialects/sqlite3/schema/internal/sqlite-ddl-operations.js

@@ -0,0 +1,41 @@
+function copyData(sourceTable, targetTable, columns) {
+  return `INSERT INTO "${targetTable}" SELECT ${
+    columns === undefined
+      ? '*'
+      : columns.map((column) => `"${column}"`).join(', ')
+  } FROM "${sourceTable}";`;
+}
+
+function dropOriginal(tableName) {
+  return `DROP TABLE "${tableName}"`;
+}
+
+function renameTable(tableName, alteredName) {
+  return `ALTER TABLE "${tableName}" RENAME TO "${alteredName}"`;
+}
+
+function getTableSql(tableName) {
+  return `SELECT type, sql FROM sqlite_master WHERE (type='table' OR (type='index' AND sql IS NOT NULL)) AND lower(tbl_name)='${tableName.toLowerCase()}'`;
+}
+
+function isForeignCheckEnabled() {
+  return `PRAGMA foreign_keys`;
+}
+
+function setForeignCheck(enable) {
+  return `PRAGMA foreign_keys = ${enable ? 'ON' : 'OFF'}`;
+}
+
+function executeForeignCheck() {
+  return `PRAGMA foreign_key_check`;
+}
+
+module.exports = {
+  copyData,
+  dropOriginal,
+  renameTable,
+  getTableSql,
+  isForeignCheckEnabled,
+  setForeignCheck,
+  executeForeignCheck,
+};

package/.output/server/node_modules/knex/lib/dialects/sqlite3/schema/internal/tokenizer.js

@@ -0,0 +1,38 @@
+function tokenize(text, tokens) {
+  const compiledRegex = new RegExp(
+    Object.entries(tokens)
+      .map(([type, regex]) => `(?<${type}>${regex.source})`)
+      .join('|'),
+    'yi'
+  );
+
+  let index = 0;
+  const ast = [];
+
+  while (index < text.length) {
+    compiledRegex.lastIndex = index;
+    const result = text.match(compiledRegex);
+
+    if (result !== null) {
+      const [type, text] = Object.entries(result.groups).find(
+        ([name, group]) => group !== undefined
+      );
+
+      index += text.length;
+
+      if (!type.startsWith('_')) {
+        ast.push({ type, text });
+      }
+    } else {
+      throw new Error(
+        `No matching tokenizer rule found at: [${text.substring(index)}]`
+      );
+    }
+  }
+
+  return ast;
+}
+
+module.exports = {
+  tokenize,
+};