alinea/dist/chunks/chunk-PNILF4WM.js

Headless git-based CMS

// node_modules/rado/dist/core/Internal.js
var internalData = Symbol();
var internalSql = Symbol();
var internalSelection = Symbol();
var internalTarget = Symbol();
var internalQuery = Symbol();
var internalBatch = Symbol();
var internalTable = Symbol();
var internalField = Symbol();
var internalResolver = Symbol();
var internalConstraint = Symbol();
var internalInclude = Symbol();
var getData = (obj) => obj[internalData];
var hasSql = (obj) => internalSql in obj;
var getSql = (obj) => obj[internalSql];
var hasSelection = (obj) => internalSelection in obj;
var getSelection = (obj) => obj[internalSelection];
var hasTarget = (obj) => internalTarget in obj;
var getTarget = (obj) => obj[internalTarget];
var hasQuery = (obj) => internalQuery in obj;
var getQuery = (obj) => obj[internalQuery];
var hasTable = (obj) => internalTable in obj;
var getTable = (obj) => obj[internalTable];
var hasField = (obj) => internalField in obj;
var getField = (obj) => obj[internalField];
var getResolver = (obj) => obj[internalResolver];
var hasConstraint = (obj) => internalConstraint in obj;
var getConstraint = (obj) => obj[internalConstraint];

// node_modules/rado/dist/core/Sql.js
var Chunk = class {
  constructor(type, inner) {
    this.type = type;
    this.inner = inner;
  }
};
var Sql = class _Sql {
  static SELF_TARGET = "$$self";
  alias;
  mapFromDriverValue;
  [internalSql] = this;
  #chunks;
  constructor(chunks = []) {
    this.#chunks = chunks;
  }
  as(name) {
    this.alias = name;
    return this;
  }
  mapWith(decoder) {
    const res = this;
    res.mapFromDriverValue = typeof decoder === "function" ? decoder : decoder.mapFromDriverValue;
    return res;
  }
  chunk(type, inner) {
    this.#chunks.push(new Chunk(type, inner));
    return this;
  }
  unsafe(sql2) {
    if (sql2.length > 0) this.chunk("emitUnsafe", sql2);
    return this;
  }
  field(field) {
    return this.chunk("emitField", field);
  }
  add(sql2) {
    const inner = getSql(sql2);
    if (!(inner instanceof _Sql)) throw new Error("Invalid SQL");
    this.#chunks.push(...inner.#chunks);
    return this;
  }
  value(value) {
    return this.chunk("emitValue", value);
  }
  getValue() {
    if (this.#chunks.length !== 1) return;
    const chunk = this.#chunks[0];
    if (chunk?.type === "emitValue") return chunk.inner;
  }
  inline(value) {
    return this.chunk("emitInline", value);
  }
  jsonPath(path) {
    const inner = path.target.#chunks[0];
    if (inner?.type !== "emitJsonPath") return this.chunk("emitJsonPath", path);
    const innerPath = inner.inner;
    return this.chunk("emitJsonPath", {
      ...innerPath,
      segments: [...innerPath.segments, ...path.segments]
    });
  }
  forSelection() {
    if (this.#chunks.length === 1) {
      const first = this.#chunks[0];
      if (first.type === "emitJsonPath")
        return sql.jsonPath({ ...first.inner, asSql: false }).mapWith(this);
    }
    return this;
  }
  placeholder(name) {
    return this.chunk("emitPlaceholder", name);
  }
  identifier(identifier) {
    return this.chunk("emitIdentifierOrSelf", identifier);
  }
  inlineValues() {
    return new _Sql(
      this.#chunks.map((chunk) => {
        if (chunk.type !== "emitValue") return chunk;
        return new Chunk("emitInline", chunk.inner);
      })
    );
  }
  inlineFields(withTableName) {
    return new _Sql(
      this.#chunks.flatMap((chunk) => {
        if (chunk.type !== "emitField") return [chunk];
        const data = chunk.inner;
        if (withTableName)
          return [
            new Chunk("emitIdentifierOrSelf", data.targetName),
            new Chunk("emitUnsafe", "."),
            new Chunk("emitIdentifier", data.fieldName)
          ];
        return [new Chunk("emitIdentifier", data.fieldName)];
      })
    );
  }
  nameSelf(name) {
    return sql.chunk("emitSelf", { name, inner: this });
  }
  emitTo(emitter) {
    for (const chunk of this.#chunks) emitter[chunk.type](chunk.inner);
  }
};
function sql(strings, ...inner) {
  const sql2 = new Sql();
  for (let i = 0; i < strings.length; i++) {
    sql2.unsafe(strings[i]);
    if (i < inner.length) {
      const insert = inner[i];
      if (insert !== null && typeof insert === "object" && hasSql(insert))
        sql2.add(insert);
      else sql2.value(insert);
    }
  }
  return sql2;
}
((sql2) => {
  function empty() {
    return new Sql();
  }
  sql2.empty = empty;
  function unsafe(directSql) {
    return empty().unsafe(String(directSql));
  }
  sql2.unsafe = unsafe;
  function value(value2) {
    return empty().value(value2);
  }
  sql2.value = value;
  function inline(value2) {
    return empty().inline(value2);
  }
  sql2.inline = inline;
  function placeholder(name) {
    return empty().placeholder(name);
  }
  sql2.placeholder = placeholder;
  function identifier(identifier2) {
    return empty().identifier(identifier2);
  }
  sql2.identifier = identifier;
  function field(field2) {
    return empty().field(field2);
  }
  sql2.field = field;
  function jsonPath(path) {
    return empty().jsonPath(path);
  }
  sql2.jsonPath = jsonPath;
  function chunk(type, inner) {
    return empty().chunk(type, inner);
  }
  sql2.chunk = chunk;
  function universal(runtimes) {
    return empty().chunk("emitUniversal", runtimes);
  }
  sql2.universal = universal;
  function query(ast) {
    return join(
      Object.entries(ast).map(([key, value2]) => {
        const statement = key.replace(/([A-Z])/g, " $1").toLocaleLowerCase();
        if (value2 === true) return sql2.unsafe(statement);
        if (Array.isArray(value2)) value2 = join(value2);
        if (!key) return value2;
        return value2 && sql2`${sql2.unsafe(statement)} ${value2}`;
      })
    );
  }
  sql2.query = query;
  function join(items, separator = sql2` `) {
    const parts = items.filter(Boolean);
    const sql3 = new Sql();
    for (let i = 0; i < parts.length; i++) {
      if (i > 0) sql3.add(separator);
      sql3.add(parts[i]);
    }
    return sql3;
  }
  sql2.join = join;
})(sql || (sql = {}));

// node_modules/rado/dist/core/expr/Input.js
function input(value) {
  if (typeof value !== "object" || value === null) return sql.value(value);
  if (hasTable(value)) return sql.identifier(getTable(value).name);
  if (hasSql(value)) return getSql(value);
  return sql.value(value);
}

export {
  internalData,
  internalSql,
  internalSelection,
  internalTarget,
  internalQuery,
  internalTable,
  internalField,
  internalResolver,
  internalConstraint,
  getData,
  hasSql,
  getSql,
  hasSelection,
  getSelection,
  hasTarget,
  getTarget,
  hasQuery,
  getQuery,
  hasTable,
  getTable,
  hasField,
  getField,
  getResolver,
  hasConstraint,
  getConstraint,
  Sql,
  sql,
  input
};