alinea/dist/chunks/chunk-H54PGW2N.js

Headless git-based CMS

import {
  getConstraint,
  getData,
  getField,
  getSql,
  hasConstraint,
  input,
  internalData,
  internalField,
  internalSql,
  internalTable,
  internalTarget,
  sql
} from "./chunk-PNILF4WM.js";

// node_modules/rado/dist/core/Index.js
var IndexData = class {
  fields;
  concurrently;
  unique;
  only;
  using;
  order;
  nulls;
  where;
};
var IndexApi = class extends IndexData {
  toSql(tableName, indexName, ifNotExists) {
    return sql.join([
      sql`create`,
      this.unique && sql`unique`,
      sql`index`,
      ifNotExists && sql`if not exists`,
      sql.identifier(indexName),
      sql`on`,
      sql`${sql.identifier(tableName)}(${sql.join(this.fields, sql`, `)})`,
      this.where && sql`where ${this.where}`
    ]).inlineFields(false);
  }
};
var Index = class _Index {
  [internalData];
  constructor(data) {
    this[internalData] = Object.assign(new IndexApi(), data);
  }
  on(...fields) {
    return new _Index({ ...getData(this), fields });
  }
  concurrently() {
    return new _Index({ ...getData(this), concurrently: true });
  }
  only() {
    return new _Index({ ...getData(this), only: true });
  }
  using(using) {
    return new _Index({ ...getData(this), using });
  }
  asc() {
    return new _Index({ ...getData(this), order: "asc" });
  }
  desc() {
    return new _Index({ ...getData(this), order: "desc" });
  }
  nullsFirst() {
    return new _Index({ ...getData(this), nulls: "first" });
  }
  nullsLast() {
    return new _Index({ ...getData(this), nulls: "last" });
  }
  where(where) {
    return new _Index({ ...getData(this), where });
  }
};

// node_modules/rado/dist/core/expr/Field.js
var Field = class {
  [internalField];
  [internalSql];
  constructor(targetName, fieldName, options = {}) {
    const field = { targetName, fieldName };
    this[internalField] = field;
    const expr = sql.field(field).as(fieldName).mapWith(options);
    this[internalSql] = expr;
  }
};

// node_modules/rado/dist/core/expr/Functions.js
function callFunction(name, args) {
  return sql`${name}(${sql.join(args.map(input), sql`, `)})`;
}
function get(target, method) {
  return target[method] ??= (...args) => {
    return callFunction(sql.identifier(method), args);
  };
}
var Functions = new Proxy(/* @__PURE__ */ Object.create(null), { get });

// node_modules/rado/dist/core/expr/Json.js
var INDEX_PROPERTY = /^\d+$/;
function jsonExpr(e) {
  return new Proxy(e, {
    get(target, prop) {
      if (typeof prop !== "string") return Reflect.get(target, prop);
      const isNumber = INDEX_PROPERTY.test(prop);
      return jsonExpr(
        sql.jsonPath({
          target: getSql(target),
          asSql: true,
          segments: [isNumber ? Number(prop) : prop]
        }).mapWith({
          mapFromDriverValue(value, specs) {
            return specs.parsesJson ? value : JSON.parse(value);
          }
        })
      );
    }
  });
}
function jsonAggregateArray(...args) {
  return callFunction(
    sql.universal({
      // Once sqlite 3.45+ is more commonplace we can use jsonb_group_array
      sqlite: sql`json_group_array`,
      postgres: sql`jsonb_agg`,
      mysql: sql`json_arrayagg`
    }),
    args
  );
}
function jsonArray(...args) {
  return callFunction(
    sql.universal({
      postgres: sql`jsonb_build_array`,
      default: sql`json_array`
    }),
    args
  );
}

// node_modules/rado/dist/core/Table.js
var { assign, fromEntries, entries, keys } = Object;
var TableData = class {
  name;
  alias;
  schemaName;
  columns;
  config;
};
var TableApi = class extends TableData {
  get aliased() {
    return this.alias ?? this.name;
  }
  identifier(altName) {
    return sql.join(
      [
        this.schemaName ? sql.identifier(this.schemaName) : void 0,
        sql.identifier(altName ?? this.name)
      ],
      sql`.`
    );
  }
  target() {
    return sql.join([
      this.identifier(),
      this.alias ? sql`as ${sql.identifier(this.alias)}` : void 0
    ]);
  }
  columnDefinition(name) {
    const columnData = this.columns[name];
    const column2 = getData(columnData);
    const columnName = sql.identifier(column2.name ?? name);
    return sql`${columnName} ${sql.chunk("emitColumn", column2)}`;
  }
  createDefinition() {
    const createColumns = keys(this.columns).map(
      (name) => this.columnDefinition(name)
    );
    const createConstraints = entries(this.config ?? {}).filter(([, constraint]) => hasConstraint(constraint)).map(
      ([name, constraint]) => sql`constraint ${sql.identifier(name)} ${getConstraint(
        constraint
      )}`
    );
    return sql.join(createColumns.concat(createConstraints), sql`, `);
  }
  listColumns() {
    return sql.join(
      entries(this.columns).map(([name, column2]) => {
        const columnApi = getData(column2);
        const { name: givenName } = columnApi;
        return sql.identifier(givenName ?? name);
      }),
      sql`, `
    );
  }
  fields() {
    return fromEntries(
      entries(this.columns).map(([name, column2]) => {
        const columnApi = getData(column2);
        const { name: givenName } = columnApi;
        const field = new Field(this.aliased, givenName ?? name, columnApi);
        if (columnApi.json) return [name, jsonExpr(field)];
        return [name, field];
      })
    );
  }
  createTable(altName, ifNotExists = false) {
    return sql.join([
      sql`create table`,
      ifNotExists ? sql`if not exists` : void 0,
      this.identifier(altName),
      sql`(${this.createDefinition()})`
    ]);
  }
  createIndexes() {
    return entries(this.indexes()).map(([name, index]) => {
      const indexApi = getData(index);
      return indexApi.toSql(this.name, name, false);
    });
  }
  create() {
    return [this.createTable(), ...this.createIndexes()];
  }
  drop() {
    return sql`drop table ${this.target()}`;
  }
  indexes() {
    return fromEntries(
      entries(this.config ?? {}).filter(([, config]) => config instanceof Index)
    );
  }
};
function table(name, columns, config, schemaName) {
  const api = assign(new TableApi(), {
    name,
    schemaName,
    columns
  });
  const table2 = {
    [internalTable]: api,
    [internalTarget]: api.target(),
    ...api.fields()
  };
  if (config) api.config = config(table2);
  return table2;
}

// node_modules/rado/dist/core/Column.js
var Column = class _Column {
  [internalData];
  constructor(data) {
    this[internalData] = data;
  }
  notNull() {
    return new _Column({
      ...getData(this),
      notNull: true
    });
  }
  $defaultFn(value) {
    return this.$default(value);
  }
  $default(value) {
    return new _Column({
      ...getData(this),
      $default() {
        return input(value instanceof Function ? value() : value);
      }
    });
  }
  default(value) {
    return new _Column({
      ...getData(this),
      defaultValue: input(value).inlineValues()
    });
  }
  defaultNow() {
    return new _Column({
      ...getData(this),
      defaultValue: sql.unsafe("now()")
    });
  }
  primaryKey() {
    return new _Column({ ...getData(this), primary: true });
  }
  unique(name) {
    return new _Column({ ...getData(this), isUnique: true });
  }
  references(foreignField) {
    return new _Column({
      ...getData(this),
      references() {
        return getField(
          typeof foreignField === "function" ? foreignField() : foreignField
        );
      }
    });
  }
  $type() {
    return this;
  }
};
function createColumn(data) {
  return new Column(data);
}
var column = new Proxy(createColumn, {
  get(target, method) {
    return target[method] ??= (...args) => {
      while (args.length > 0)
        if (args.at(-1) === void 0) args.pop();
        else break;
      if (args.length === 0) return sql.unsafe(method);
      return sql`${sql.unsafe(method)}(${sql.join(
        args.map(sql.inline),
        sql`, `
      )})`;
    };
  }
});

export {
  column,
  callFunction,
  Functions,
  Field,
  jsonAggregateArray,
  jsonArray,
  table
};