shiro-orm/dist/index.js

Access your RONIN database via TypeScript.

import {
  QUERY_SYMBOLS,
  isStorableObject,
  mergeOptions,
  runQueries,
  runQueriesWithStorageAndTriggers
} from "./chunk-5VI443KP.js";
import {
  getBatchProxy,
  getBatchProxySQL,
  getSyntaxProxy,
  getSyntaxProxySQL
} from "./chunk-NXXOROUL.js";

// src/utils/handlers.ts
var queriesHandler = async (queries, options = {}) => {
  if (!options.token && typeof process !== "undefined") {
    const token2 = typeof process?.env !== "undefined" ? process.env.RONIN_TOKEN : typeof import.meta?.env !== "undefined" ? import.meta.env.RONIN_TOKEN : void 0;
    if (!token2 || token2 === "undefined") {
      const message = "Please specify the `RONIN_TOKEN` environment variable or set the `token` option when invoking RONIN.";
      throw new Error(message);
    }
    options.token = token2;
  }
  const token = options.token;
  if (!token) {
    let message = "When invoking RONIN from an edge runtime, the";
    message += " `token` option must be set.";
    throw new Error(message);
  }
  if ("statements" in queries) {
    const results = await runQueries(
      queries.statements.map((statement) => ({ statement })),
      options
    );
    return results.map(({ result }) => result);
  }
  if (options.database) {
    const queryList = { [options.database]: queries };
    const result = await runQueriesWithStorageAndTriggers(queryList, options);
    return result[options.database];
  }
  return runQueriesWithStorageAndTriggers(queries, options);
};
var queryHandler = async (query, options) => {
  const input = "statement" in query ? { statements: [query.statement] } : [query];
  const results = await queriesHandler(input, options);
  return results[0];
};

// src/index.ts
var createSyntaxFactory = (options) => {
  const callback = (defaultQuery, queryOptions) => {
    const query = defaultQuery;
    return queryHandler(query[QUERY_SYMBOLS.QUERY], mergeOptions(options, queryOptions));
  };
  const replacer = (value) => isStorableObject(value) ? value : void 0;
  return {
    // Query types for interacting with records.
    get: getSyntaxProxy({
      root: `${QUERY_SYMBOLS.QUERY}.get`,
      callback,
      replacer
    }),
    set: getSyntaxProxy({
      root: `${QUERY_SYMBOLS.QUERY}.set`,
      callback,
      replacer
    }),
    add: getSyntaxProxy({
      root: `${QUERY_SYMBOLS.QUERY}.add`,
      callback,
      replacer
    }),
    remove: getSyntaxProxy({
      root: `${QUERY_SYMBOLS.QUERY}.remove`,
      callback,
      replacer
    }),
    count: getSyntaxProxy({
      root: `${QUERY_SYMBOLS.QUERY}.count`,
      callback,
      replacer
    }),
    // Query types for interacting with the database schema.
    list: getSyntaxProxy({
      root: `${QUERY_SYMBOLS.QUERY}.list`,
      callback,
      replacer
    }),
    create: getSyntaxProxy({
      root: `${QUERY_SYMBOLS.QUERY}.create`,
      callback,
      replacer
    }),
    alter: getSyntaxProxy({
      root: `${QUERY_SYMBOLS.QUERY}.alter`,
      callback,
      replacer
    }),
    drop: getSyntaxProxy({
      root: `${QUERY_SYMBOLS.QUERY}.drop`,
      callback,
      replacer
    }),
    // Function for executing a transaction containing multiple queries.
    batch: (operations, queryOptions) => {
      const batchOperations = operations;
      const queries = getBatchProxy(batchOperations).map(({ structure }) => structure);
      const finalOptions = mergeOptions(options, queryOptions);
      return queriesHandler(queries, finalOptions);
    },
    sql: getSyntaxProxySQL({
      callback: (statement) => queryHandler({ statement }, mergeOptions(options, {}))
    }),
    sqlBatch: (operations, queryOptions) => {
      const batchOperations = operations;
      const statements = getBatchProxySQL(batchOperations);
      const finalOptions = mergeOptions(options, queryOptions);
      return queriesHandler({ statements }, finalOptions);
    }
  };
};
var factory = createSyntaxFactory({});
var get = factory.get;
var set = factory.set;
var add = factory.add;
var remove = factory.remove;
var count = factory.count;
var list = factory.list;
var create = factory.create;
var alter = factory.alter;
var drop = factory.drop;
var batch = factory.batch;
var sql = factory.sql;
var sqlBatch = factory.sqlBatch;
var index_default = createSyntaxFactory;
export {
  add,
  alter,
  batch,
  count,
  create,
  createSyntaxFactory,
  index_default as default,
  drop,
  get,
  list,
  remove,
  set,
  sql,
  sqlBatch
};