@proofkit/fmodata/dist/esm/orm/table.js

FileMaker OData API client

var __defProp = Object.defineProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
var _a, _b, _c, _d, _e, _f, _g, _h, _i;
import { Column } from "./column.js";
const FMTableName = Symbol.for("fmodata:FMTableName");
const FMTableEntityId = Symbol.for("fmodata:FMTableEntityId");
const FMTableSchema = Symbol.for("fmodata:FMTableSchema");
const FMTableFields = Symbol.for("fmodata:FMTableFields");
const FMTableNavigationPaths = Symbol.for("fmodata:FMTableNavigationPaths");
const FMTableDefaultSelect = Symbol.for("fmodata:FMTableDefaultSelect");
const FMTableBaseTableConfig = Symbol.for("fmodata:FMTableBaseTableConfig");
const FMTableUseEntityIds = Symbol.for("fmodata:FMTableUseEntityIds");
const FMTableComment = Symbol.for("fmodata:FMTableComment");
_i = FMTableName, _h = FMTableEntityId, _g = FMTableUseEntityIds, _f = FMTableComment, _e = FMTableSchema, _d = FMTableFields, _c = FMTableNavigationPaths, _b = FMTableDefaultSelect, _a = FMTableBaseTableConfig;
class FMTable {
  constructor(config) {
    /** @internal */
    __publicField(this, _i);
    /** @internal */
    __publicField(this, _h);
    /** @internal */
    __publicField(this, _g);
    /** @internal */
    __publicField(this, _f);
    /** @internal */
    __publicField(this, _e);
    /** @internal */
    __publicField(this, _d);
    /** @internal */
    __publicField(this, _c);
    /** @internal */
    // biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any Column configuration
    __publicField(this, _b);
    /** @internal */
    __publicField(this, _a);
    this[FMTableName] = config.name;
    this[FMTableEntityId] = config.entityId;
    this[FMTableUseEntityIds] = config.useEntityIds;
    this[FMTableComment] = config.comment;
    this[FMTableSchema] = config.schema;
    this[FMTableFields] = config.fields;
    this[FMTableNavigationPaths] = config.navigationPaths;
    this[FMTableDefaultSelect] = config.defaultSelect;
    this[FMTableBaseTableConfig] = config.baseTableConfig;
  }
}
/**
 * Internal Symbols for accessing table metadata.
 * @internal - Not intended for public use. Access table properties via columns instead.
 */
__publicField(FMTable, "Symbol", {
  Name: FMTableName,
  EntityId: FMTableEntityId,
  UseEntityIds: FMTableUseEntityIds,
  Schema: FMTableSchema,
  Fields: FMTableFields,
  NavigationPaths: FMTableNavigationPaths,
  DefaultSelect: FMTableDefaultSelect,
  BaseTableConfig: FMTableBaseTableConfig,
  Comment: FMTableComment
});
function fmTableOccurrence(name, fields, options) {
  const fieldConfigs = Object.entries(fields).map(([fieldName, builder]) => ({
    fieldName,
    // biome-ignore lint/suspicious/noExplicitAny: Internal property access for builder pattern
    config: builder._getConfig()
  }));
  const primaryKeyField = fieldConfigs.find((f) => f.config.primaryKey);
  const idField = primaryKeyField == null ? void 0 : primaryKeyField.fieldName;
  const required = fieldConfigs.filter((f) => f.config.notNull).map((f) => f.fieldName);
  const readOnly = fieldConfigs.filter((f) => f.config.readOnly).map((f) => f.fieldName);
  const containerFields = fieldConfigs.filter((f) => f.config.fieldType === "container").map((f) => f.fieldName);
  const fmfIds = {};
  for (const { fieldName, config } of fieldConfigs) {
    if (config.entityId) {
      fmfIds[fieldName] = config.entityId;
    }
  }
  const outputSchema = {};
  const inputSchema = {};
  for (const { fieldName, config } of fieldConfigs) {
    if (config.outputValidator) {
      outputSchema[fieldName] = config.outputValidator;
    }
    if (config.inputValidator) {
      inputSchema[fieldName] = config.inputValidator;
    }
  }
  const baseTableConfig = {
    schema: outputSchema,
    inputSchema: Object.keys(inputSchema).length > 0 ? inputSchema : void 0,
    idField,
    required,
    readOnly,
    containerFields,
    fmfIds: Object.keys(fmfIds).length > 0 ? fmfIds : void 0
  };
  const columns = {};
  for (const [fieldName, builder] of Object.entries(fields)) {
    const config = builder._getConfig();
    columns[fieldName] = new Column({
      fieldName: String(fieldName),
      entityId: config.entityId,
      tableName: name,
      tableEntityId: options == null ? void 0 : options.entityId,
      inputValidator: config.inputValidator,
      fieldType: config.fieldType
    });
  }
  const defaultSelectOption = (options == null ? void 0 : options.defaultSelect) ?? "schema";
  const resolvedDefaultSelect = typeof defaultSelectOption === "function" ? defaultSelectOption(columns) : defaultSelectOption;
  const navigationPaths = (options == null ? void 0 : options.navigationPaths) ?? [];
  const table = new FMTable({
    name,
    entityId: options == null ? void 0 : options.entityId,
    useEntityIds: options == null ? void 0 : options.useEntityIds,
    comment: options == null ? void 0 : options.comment,
    schema: outputSchema,
    fields,
    navigationPaths,
    defaultSelect: resolvedDefaultSelect,
    baseTableConfig
  });
  Object.assign(table, columns);
  return table;
}
function getTableName(table) {
  return table[FMTableName];
}
function getTableSchema(table) {
  return table[FMTableSchema];
}
function getNavigationPaths(table) {
  return table[FMTableNavigationPaths];
}
function getDefaultSelect(table) {
  return table[FMTableDefaultSelect];
}
function getBaseTableConfig(table) {
  return table[FMTableBaseTableConfig];
}
function isUsingEntityIds(table) {
  return table[FMTableEntityId] !== void 0 && table[FMTableBaseTableConfig].fmfIds !== void 0;
}
function getFieldId(table, fieldName) {
  const config = table[FMTableBaseTableConfig];
  if (config.fmfIds && fieldName in config.fmfIds) {
    const fieldId = config.fmfIds[fieldName];
    if (fieldId) {
      return fieldId;
    }
  }
  return fieldName;
}
function getFieldName(table, fieldId) {
  const config = table[FMTableBaseTableConfig];
  if (config.fmfIds) {
    for (const [fieldName, fmfId] of Object.entries(config.fmfIds)) {
      if (fmfId === fieldId) {
        return fieldName;
      }
    }
  }
  return fieldId;
}
function getTableId(table) {
  return table[FMTableEntityId] ?? table[FMTableName];
}
function getTableColumns(table) {
  var _a2;
  const fields = table[FMTableFields];
  const tableName = table[FMTableName];
  const tableEntityId = table[FMTableEntityId];
  const baseConfig = table[FMTableBaseTableConfig];
  const columns = {};
  for (const [fieldName, builder] of Object.entries(fields)) {
    const config = builder._getConfig();
    columns[fieldName] = new Column({
      fieldName: String(fieldName),
      entityId: (_a2 = baseConfig.fmfIds) == null ? void 0 : _a2[fieldName],
      tableName,
      tableEntityId,
      inputValidator: config.inputValidator,
      fieldType: config.fieldType
    });
  }
  return columns;
}
export {
  FMTable,
  fmTableOccurrence,
  getBaseTableConfig,
  getDefaultSelect,
  getFieldId,
  getFieldName,
  getNavigationPaths,
  getTableColumns,
  getTableId,
  getTableName,
  getTableSchema,
  isUsingEntityIds
};
//# sourceMappingURL=table.js.map