@igorchugurov/public-api-sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,1521 @@
+'use strict';
+
+var ssr = require('@supabase/ssr');
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+// src/types/entity-types.ts
+function isFieldValue(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value instanceof Date || Array.isArray(value) && value.every((v) => typeof v === "string") || value === null || value === void 0;
+}
+function isEntityData(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  return Object.values(value).every(isFieldValue);
+}
+function getFieldValue(data, fieldName, defaultValue) {
+  const value = data[fieldName];
+  return value !== void 0 ? value : defaultValue;
+}
+
+// src/errors.ts
+var SDKError = class extends Error {
+  constructor(code, message, statusCode, details) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+    this.name = "SDKError";
+  }
+};
+var NotFoundError = class extends SDKError {
+  constructor(resource, id) {
+    super(
+      "NOT_FOUND",
+      id ? `${resource} with id ${id} not found` : `${resource} not found`,
+      404
+    );
+  }
+};
+var PermissionDeniedError = class extends SDKError {
+  constructor(action, resource) {
+    super(
+      "PERMISSION_DENIED",
+      `Permission denied: cannot ${action} ${resource}`,
+      403
+    );
+  }
+};
+var ValidationError = class extends SDKError {
+  constructor(field, message) {
+    super(
+      "VALIDATION_ERROR",
+      `Validation failed for ${field}: ${message}`,
+      400,
+      {
+        field,
+        message
+      }
+    );
+  }
+};
+var AuthenticationError = class extends SDKError {
+  constructor(message = "Authentication required") {
+    super("AUTHENTICATION_REQUIRED", message, 401);
+  }
+};
+function handleSupabaseError(error) {
+  if (error.code === "PGRST116") {
+    throw new NotFoundError("Resource");
+  }
+  if (error.code === "23505") {
+    throw new SDKError("DUPLICATE_ENTRY", "Duplicate entry", 409);
+  }
+  if (error.code === "23503") {
+    throw new SDKError("FOREIGN_KEY_VIOLATION", "Foreign key violation", 400);
+  }
+  if (error.code === "42501") {
+    throw new PermissionDeniedError("access", "resource");
+  }
+  throw new SDKError(
+    "UNKNOWN_ERROR",
+    error.message || "Unknown error",
+    500,
+    error
+  );
+}
+function handleInstanceError(error, instanceId) {
+  if ((error == null ? void 0 : error.code) === "PGRST116") {
+    throw new NotFoundError("Entity instance", instanceId);
+  }
+  if ((error == null ? void 0 : error.code) === "42501") {
+    throw new PermissionDeniedError("read", `entity instance ${instanceId}`);
+  }
+  handleSupabaseError(error);
+}
+
+// src/utils.ts
+function validateInstanceData(data, fields) {
+  const errors = [];
+  for (const field of fields) {
+    const value = data[field.name];
+    if (field.required && (value === void 0 || value === null || value === "")) {
+      errors.push({
+        field: field.name,
+        message: `${field.name} is required`
+      });
+      continue;
+    }
+    if (value !== void 0 && value !== null) {
+      const typeError = validateFieldType(value, field);
+      if (typeError) {
+        errors.push({ field: field.name, message: typeError });
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function validateFieldType(value, field) {
+  switch (field.dbType) {
+    case "varchar":
+    case "timestamptz":
+      if (typeof value !== "string") {
+        return `Expected string, got ${typeof value}`;
+      }
+      break;
+    case "float":
+      if (typeof value !== "number") {
+        return `Expected number, got ${typeof value}`;
+      }
+      break;
+    case "boolean":
+      if (typeof value !== "boolean") {
+        return `Expected boolean, got ${typeof value}`;
+      }
+      break;
+    // Relations - должны быть массивами строк (ID)
+    case "manyToMany":
+    case "oneToMany":
+      if (!Array.isArray(value) || !value.every((v) => typeof v === "string")) {
+        return `Expected array of strings (IDs), got ${typeof value}`;
+      }
+      break;
+    case "manyToOne":
+    case "oneToOne":
+      if (typeof value !== "string") {
+        return `Expected string (ID), got ${typeof value}`;
+      }
+      break;
+  }
+  return null;
+}
+function normalizeFieldValue(value, field) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  switch (field.dbType) {
+    case "float":
+      return typeof value === "string" ? parseFloat(value) : value;
+    case "boolean":
+      return typeof value === "string" ? value.toLowerCase() === "true" : Boolean(value);
+    case "varchar":
+    case "timestamptz":
+      return String(value);
+    default:
+      return value;
+  }
+}
+function toCamelCase(str) {
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function toSnakeCase(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+
+// src/utils/generateUIConfig.ts
+function generateUIConfig(entityDefinition, fields) {
+  const defaults = generateDefaults(entityDefinition, fields);
+  if (entityDefinition.uiConfig) {
+    return deepMerge(
+      defaults,
+      entityDefinition.uiConfig
+    );
+  }
+  return defaults;
+}
+function generateDefaults(entityDefinition, fields) {
+  var _a, _b, _c;
+  const name = entityDefinition.name;
+  const nameLower = name.toLowerCase();
+  const namePlural = pluralize(nameLower);
+  const tableName = entityDefinition.tableName;
+  const searchableFields = fields.filter((f) => f.searchable).map((f) => f.name);
+  const finalSearchableFields = searchableFields.length > 0 ? searchableFields : ["name"];
+  const list = {
+    pageTitle: name,
+    searchPlaceholder: `Search for ${namePlural}...`,
+    emptyStateTitle: `You have no ${namePlural}`,
+    emptyStateMessages: [
+      `${name}s that you create will end up here.`,
+      `Add a ${nameLower} to get started.`
+    ],
+    showCreateButton: true,
+    createButtonText: `New ${nameLower}`,
+    showSearch: true,
+    enablePagination: (_a = entityDefinition.enablePagination) != null ? _a : true,
+    pageSize: (_b = entityDefinition.pageSize) != null ? _b : 20,
+    enableFilters: (_c = entityDefinition.enableFilters) != null ? _c : false,
+    searchableFields: finalSearchableFields,
+    columns: generateColumns(fields)
+  };
+  const form = {
+    createPageTitle: `Create new ${nameLower}`,
+    editPageTitle: `Edit ${nameLower}`,
+    pageHeader: `${name} details`,
+    createButtonLabel: "Create",
+    updateButtonLabel: "Update",
+    cancelButtonLabel: "Cancel",
+    sectionTitles: {
+      0: entityDefinition.titleSection0 || "General Information",
+      1: entityDefinition.titleSection1 || "Section 1",
+      2: entityDefinition.titleSection2 || "Section 2",
+      3: entityDefinition.titleSection3 || "Section 3"
+    }
+  };
+  const messages = {
+    afterCreate: `${name} was created successfully!`,
+    afterUpdate: `${name} was updated successfully!`,
+    afterDelete: `${name} was deleted successfully!`,
+    errorCreate: `Failed to create ${nameLower}. Please try again.`,
+    errorUpdate: `Failed to update ${nameLower}. Please try again.`,
+    deleteModalTitle: `Confirm deleting ${nameLower}`,
+    deleteModalText: `Are you sure you want to delete "{itemName}"? This action cannot be undone.`,
+    deleteModalButtonText: "Delete",
+    reloadEvents: {
+      create: `reload${name}`,
+      update: `reload${name}`,
+      delete: `reload${name}`
+    }
+  };
+  return {
+    apiUrl: `/api/${tableName}`,
+    apiUrlAll: `/api/entity-instances/all`,
+    list,
+    form,
+    messages
+  };
+}
+function isRelationField(field) {
+  return field.dbType === "manyToOne" || field.dbType === "oneToOne" || field.dbType === "manyToMany" || field.dbType === "oneToMany";
+}
+function generateColumns(fields) {
+  const displayFields = fields.filter((f) => f.displayInTable).sort((a, b) => a.displayIndex - b.displayIndex);
+  const columns = displayFields.map((field, index) => {
+    const columnType = index === 0 ? "naigateToDetails" : getColumnType(field);
+    const isRelation = isRelationField(field);
+    const column = __spreadValues({
+      field: field.name,
+      headerName: field.label || field.name,
+      flex: 1,
+      type: columnType,
+      sortable: true
+    }, isRelation && {
+      relationDbType: field.dbType
+    });
+    return column;
+  });
+  columns.push({
+    field: "actions",
+    headerName: "",
+    type: "actions",
+    width: 100,
+    actions: [
+      {
+        action: "edit",
+        link: true
+      },
+      {
+        action: "delete"
+      }
+    ]
+  });
+  return columns;
+}
+function getColumnType(field) {
+  if (isRelationField(field)) {
+    return "relation";
+  }
+  switch (field.type) {
+    case "date":
+      return "date";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    default:
+      return "text";
+  }
+}
+function pluralize(word) {
+  if (word.endsWith("y")) {
+    return word.slice(0, -1) + "ies";
+  }
+  if (word.endsWith("s") || word.endsWith("x") || word.endsWith("ch") || word.endsWith("sh")) {
+    return word + "es";
+  }
+  return word + "s";
+}
+function deepMerge(defaults, custom) {
+  const result = __spreadValues({}, defaults);
+  for (const key in custom) {
+    const customValue = custom[key];
+    const defaultValue = defaults[key];
+    if (customValue === void 0 || customValue === null) {
+      continue;
+    }
+    if (typeof customValue === "object" && !Array.isArray(customValue) && typeof defaultValue === "object" && !Array.isArray(defaultValue) && defaultValue !== null) {
+      result[key] = deepMerge(
+        defaultValue,
+        customValue
+      );
+    } else {
+      result[key] = customValue;
+    }
+  }
+  return result;
+}
+function getColumnsFromFields(fields) {
+  return fields.filter((field) => field.displayInTable).map((field, i) => ({
+    type: i === 0 ? "naigateToDetails" : void 0,
+    field: field.name,
+    headerName: field.label || field.name,
+    flex: 1
+  }));
+}
+function createBrowserClient(supabaseUrl, supabaseAnonKey) {
+  return ssr.createBrowserClient(supabaseUrl, supabaseAnonKey);
+}
+
+// src/base/base-client.ts
+var BasePublicAPIClient = class {
+  constructor(supabase, projectId, options = {}) {
+    this.configCache = /* @__PURE__ */ new Map();
+    var _a, _b;
+    this.supabase = supabase;
+    this.projectId = projectId;
+    this.enableCache = (_a = options.enableCache) != null ? _a : true;
+    this.cacheTTL = (_b = options.cacheTTL) != null ? _b : 5 * 60 * 1e3;
+  }
+  /**
+   * Загрузить fields для entityDefinition (с кэшированием)
+   *
+   * Флоу работы с кэшем:
+   *
+   * 1. Если enableCache === true (публичный API):
+   *    - Проверяет кэш по entityDefinitionId
+   *    - Если есть в кэше и не истек → возвращает из кэша (0 запросов к БД)
+   *    - Если нет в кэше или истек → загружает из БД и кэширует (1 запрос к БД)
+   *
+   * 2. Если enableCache === false (админка):
+   *    - Пропускает проверку кэша (эквивалент forceRefresh: true)
+   *    - Всегда загружает из БД (1 запрос к БД)
+   *    - Не сохраняет в кэш (всегда свежие данные)
+   *
+   * Используется внутри SDK для получения fields перед операциями с instances.
+   * Fields нужны для определения типов полей, relations, и уплощения данных.
+   */
+  async getFields(entityDefinitionId) {
+    const config = await this.getEntityDefinitionConfig(entityDefinitionId);
+    return config.fields;
+  }
+  /**
+   * Преобразование данных entity_definition из БД в EntityDefinitionConfig
+   */
+  transformEntityDefinitionFromDB(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      description: row.description,
+      tableName: row.table_name,
+      type: row.type,
+      projectId: row.project_id,
+      createPermission: row.create_permission,
+      readPermission: row.read_permission,
+      updatePermission: row.update_permission,
+      deletePermission: row.delete_permission,
+      titleSection0: row.title_section_0,
+      titleSection1: row.title_section_1,
+      titleSection2: row.title_section_2,
+      titleSection3: row.title_section_3,
+      uiConfig: row.ui_config,
+      enablePagination: row.enable_pagination,
+      pageSize: row.page_size,
+      enableFilters: row.enable_filters,
+      maxFileSizeMb: row.max_file_size_mb,
+      maxFilesCount: row.max_files_count,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  /**
+   * Преобразование данных field из БД в FieldConfig
+   */
+  transformFieldFromDB(row) {
+    var _a;
+    return {
+      id: row.id,
+      entityDefinitionId: row.entity_definition_id,
+      name: row.name,
+      dbType: row.db_type,
+      type: row.type,
+      label: row.label,
+      placeholder: row.placeholder,
+      description: row.description,
+      forEditPage: row.for_edit_page,
+      forCreatePage: row.for_create_page,
+      required: row.required,
+      requiredText: row.required_text,
+      forEditPageDisabled: row.for_edit_page_disabled,
+      displayIndex: row.display_index,
+      displayInTable: row.display_in_table,
+      sectionIndex: (_a = row.section_index) != null ? _a : 0,
+      isOptionTitleField: row.is_option_title_field,
+      searchable: row.searchable,
+      filterableInList: row.filterable_in_list,
+      options: row.options,
+      relatedEntityDefinitionId: row.related_entity_definition_id,
+      relationFieldId: row.relation_field_id,
+      isRelationSource: row.is_relation_source,
+      selectorRelationId: row.selector_relation_id,
+      relationFieldName: row.relation_field_name,
+      relationFieldLabel: row.relation_field_label,
+      defaultStringValue: row.default_string_value,
+      defaultNumberValue: row.default_number_value,
+      defaultBooleanValue: row.default_boolean_value,
+      defaultDateValue: row.default_date_value,
+      autoPopulate: row.auto_populate,
+      includeInSinglePma: row.include_in_single_pma,
+      includeInListPma: row.include_in_list_pma,
+      includeInSingleSa: row.include_in_single_sa,
+      includeInListSa: row.include_in_list_sa,
+      foreignKey: row.foreign_key,
+      foreignKeyValue: row.foreign_key_value,
+      typeFieldName: row.type_field_name,
+      optionsFieldName: row.options_field_name,
+      acceptFileTypes: row.accept_file_types,
+      maxFileSize: row.max_file_size,
+      maxFiles: row.max_files,
+      storageBucket: row.storage_bucket,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  /**
+   * Загрузить entityDefinition с полями одним запросом (JOIN)
+   * Кэширует всю конфигурацию целиком (entityDefinition + fields)
+   *
+   * Логика кэширования:
+   * - enableCache: true → использует кэш, сохраняет в кэш (TTL: 5 минут по умолчанию)
+   * - enableCache: false → всегда загружает из БД, не использует кэш (эквивалент forceRefresh: true)
+   *
+   * @returns EntityDefinitionConfig с полями, отсортированными по display_index
+   */
+  async getEntityDefinitionConfig(entityDefinitionId) {
+    const forceRefresh = !this.enableCache;
+    if (!forceRefresh && this.enableCache) {
+      const cached = this.configCache.get(entityDefinitionId);
+      if (cached && Date.now() < cached.expiresAt) {
+        return cached.config;
+      }
+    }
+    const { data, error } = await this.supabase.from("entity_definition").select(
+      `
+        *,
+        field!field_entity_definition_id_fkey (*)
+      `
+    ).eq("id", entityDefinitionId).single();
+    if (error || !data) {
+      throw new Error(
+        `Entity definition not found: ${(error == null ? void 0 : error.message) || "Unknown error"}`
+      );
+    }
+    const entityDefinitionData = this.transformEntityDefinitionFromDB(data);
+    const fields = (data.field || []).sort((a, b) => {
+      var _a, _b;
+      const aIndex = (_a = a.display_index) != null ? _a : 999;
+      const bIndex = (_b = b.display_index) != null ? _b : 999;
+      return aIndex - bIndex;
+    }).map((row) => this.transformFieldFromDB(row));
+    const config = __spreadProps(__spreadValues({}, entityDefinitionData), {
+      fields
+    });
+    if (this.enableCache) {
+      this.configCache.set(entityDefinitionId, {
+        config,
+        expiresAt: Date.now() + this.cacheTTL
+      });
+    }
+    return config;
+  }
+  /**
+   * Преобразование EntityDefinitionConfig в EntityDefinition
+   */
+  convertToEntityDefinition(config) {
+    return {
+      id: config.id,
+      name: config.name,
+      description: config.description,
+      tableName: config.tableName,
+      type: config.type,
+      projectId: config.projectId,
+      createPermission: config.createPermission,
+      readPermission: config.readPermission,
+      updatePermission: config.updatePermission,
+      deletePermission: config.deletePermission,
+      titleSection0: config.titleSection0,
+      titleSection1: config.titleSection1,
+      titleSection2: config.titleSection2,
+      titleSection3: config.titleSection3,
+      uiConfig: config.uiConfig,
+      enablePagination: config.enablePagination,
+      pageSize: config.pageSize,
+      enableFilters: config.enableFilters,
+      maxFileSizeMb: config.maxFileSizeMb,
+      maxFilesCount: config.maxFilesCount,
+      createdAt: config.createdAt,
+      updatedAt: config.updatedAt
+    };
+  }
+  /**
+   * Преобразование FieldConfig в Field
+   */
+  convertToField(fieldConfig) {
+    return {
+      id: fieldConfig.id,
+      entityDefinitionId: fieldConfig.entityDefinitionId,
+      name: fieldConfig.name,
+      dbType: fieldConfig.dbType,
+      type: fieldConfig.type,
+      label: fieldConfig.label,
+      placeholder: fieldConfig.placeholder,
+      description: fieldConfig.description,
+      forEditPage: fieldConfig.forEditPage,
+      forCreatePage: fieldConfig.forCreatePage,
+      required: fieldConfig.required,
+      requiredText: fieldConfig.requiredText,
+      forEditPageDisabled: fieldConfig.forEditPageDisabled,
+      displayIndex: fieldConfig.displayIndex,
+      displayInTable: fieldConfig.displayInTable,
+      sectionIndex: fieldConfig.sectionIndex,
+      isOptionTitleField: fieldConfig.isOptionTitleField,
+      searchable: fieldConfig.searchable,
+      filterableInList: fieldConfig.filterableInList,
+      options: fieldConfig.options,
+      relatedEntityDefinitionId: fieldConfig.relatedEntityDefinitionId,
+      relationFieldId: fieldConfig.relationFieldId,
+      isRelationSource: fieldConfig.isRelationSource,
+      selectorRelationId: fieldConfig.selectorRelationId,
+      relationFieldName: fieldConfig.relationFieldName,
+      relationFieldLabel: fieldConfig.relationFieldLabel,
+      defaultStringValue: fieldConfig.defaultStringValue,
+      defaultNumberValue: fieldConfig.defaultNumberValue,
+      defaultBooleanValue: fieldConfig.defaultBooleanValue,
+      defaultDateValue: fieldConfig.defaultDateValue,
+      autoPopulate: fieldConfig.autoPopulate,
+      includeInSinglePma: fieldConfig.includeInSinglePma,
+      includeInListPma: fieldConfig.includeInListPma,
+      includeInSingleSa: fieldConfig.includeInSingleSa,
+      includeInListSa: fieldConfig.includeInListSa,
+      foreignKey: fieldConfig.foreignKey,
+      foreignKeyValue: fieldConfig.foreignKeyValue,
+      typeFieldName: fieldConfig.typeFieldName,
+      optionsFieldName: fieldConfig.optionsFieldName,
+      acceptFileTypes: fieldConfig.acceptFileTypes,
+      maxFileSize: fieldConfig.maxFileSize,
+      maxFiles: fieldConfig.maxFiles,
+      storageBucket: fieldConfig.storageBucket,
+      createdAt: fieldConfig.createdAt,
+      updatedAt: fieldConfig.updatedAt
+    };
+  }
+  /**
+   * Получить entity definition с полями и сгенерированным UI конфигом
+   * Использует кэш SDK для оптимизации (если дефиниция уже загружена, не делает повторный запрос)
+   *
+   * @param entityDefinitionId - ID entity definition
+   * @returns EntityDefinition, Fields и UI конфиг, или null если не найдено
+   */
+  async getEntityDefinitionWithUIConfig(entityDefinitionId) {
+    try {
+      const config = await this.getEntityDefinitionConfig(entityDefinitionId);
+      const entityDefinition = this.convertToEntityDefinition(config);
+      const fields = config.fields.map((f) => this.convertToField(f));
+      const uiConfig = generateUIConfig(entityDefinition, fields);
+      return {
+        entityDefinition,
+        fields,
+        uiConfig
+      };
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("not found")) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Очистить кэш
+   */
+  clearCache() {
+    this.configCache.clear();
+  }
+};
+
+// src/utils/instance-utils.ts
+function transformEntityInstance(row) {
+  return {
+    id: row.id,
+    entityDefinitionId: row.entity_definition_id,
+    projectId: row.project_id,
+    data: row.data || {},
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function flattenInstance(instance, fields, relationsAsIds = false) {
+  const result = {
+    id: instance.id,
+    entityDefinitionId: instance.entityDefinitionId,
+    projectId: instance.projectId,
+    createdAt: instance.createdAt,
+    updatedAt: instance.updatedAt
+  };
+  Object.entries(instance.data || {}).forEach(([key, value]) => {
+    result[key] = value;
+  });
+  if (instance.relations) {
+    Object.entries(instance.relations).forEach(
+      ([fieldName, relatedInstances]) => {
+        if (relationsAsIds) {
+          result[fieldName] = relatedInstances.map((inst) => inst.id);
+        } else {
+          const field = fields.find((f) => f.name === fieldName);
+          if ((field == null ? void 0 : field.dbType) === "manyToOne" || (field == null ? void 0 : field.dbType) === "oneToOne") {
+            result[fieldName] = relatedInstances[0] || null;
+          } else {
+            result[fieldName] = relatedInstances;
+          }
+        }
+      }
+    );
+  }
+  return result;
+}
+
+// src/client.ts
+var _PublicAPIClient = class _PublicAPIClient extends BasePublicAPIClient {
+  constructor(supabase, projectId, mode, options = {}) {
+    super(supabase, projectId, options);
+    this.mode = mode;
+  }
+  /**
+   * Создать SDK клиент напрямую с Supabase инстансом
+   * Используется для создания через фабричные функции createServerSDK/createClientSDK
+   *
+   * @param supabase - Supabase клиент
+   * @param projectId - ID проекта
+   * @param mode - Режим работы: 'server' для SSR, 'client' для браузера
+   * @param options - Опции SDK (кэширование и т.д.)
+   */
+  static create(supabase, projectId, mode, options = {}) {
+    const cacheKey = `${mode}-${projectId}-${JSON.stringify(options)}`;
+    if (this.instances.has(cacheKey)) {
+      return this.instances.get(cacheKey);
+    }
+    const client = new _PublicAPIClient(supabase, projectId, mode, options);
+    this.instances.set(cacheKey, client);
+    return client;
+  }
+  /**
+   * Получить режим работы клиента (для отладки)
+   */
+  getMode() {
+    return this.mode;
+  }
+  /**
+   * Получить один экземпляр
+   */
+  async getInstance(entityDefinitionId, id, params) {
+    var _a;
+    try {
+      const fields = await this.getFields(entityDefinitionId);
+      const { data: instance, error: instanceError } = await this.supabase.from("entity_instance").select("*").eq("id", id).eq("entity_definition_id", entityDefinitionId).eq("project_id", this.projectId).single();
+      if (instanceError || !instance) {
+        handleInstanceError(
+          instanceError || new Error("Instance not found"),
+          id
+        );
+      }
+      const transformedInstance = transformEntityInstance(instance);
+      if (transformedInstance.entityDefinitionId !== entityDefinitionId) {
+        throw new NotFoundError("Entity instance", id);
+      }
+      const relationFields = fields.filter(
+        (f) => f.dbType === "manyToMany" || f.dbType === "manyToOne" || f.dbType === "oneToMany" || f.dbType === "oneToOne"
+      );
+      const relations = {};
+      if (relationFields.length > 0) {
+        const relationFieldIds = relationFields.map((f) => f.id).filter((id2) => Boolean(id2));
+        if (relationFieldIds.length > 0) {
+          const { data: allRelations, error: relationsError } = await this.supabase.from("entity_relation").select("target_instance_id, relation_field_id").eq("source_instance_id", id).in("relation_field_id", relationFieldIds);
+          if (relationsError) {
+            throw new SDKError(
+              "RELATIONS_LOAD_ERROR",
+              `Failed to load relations for instance ${id}: ${relationsError.message}`,
+              500,
+              relationsError
+            );
+          }
+          if (allRelations && allRelations.length > 0) {
+            const targetInstanceIds = [
+              ...new Set(allRelations.map((r) => r.target_instance_id))
+            ];
+            const { data: relatedInstances, error: instancesError } = await this.supabase.from("entity_instance").select("*").in("id", targetInstanceIds);
+            if (instancesError) {
+              throw new SDKError(
+                "RELATED_INSTANCES_LOAD_ERROR",
+                `Failed to load related instances for instance ${id}: ${instancesError.message}`,
+                500,
+                instancesError
+              );
+            }
+            if (relatedInstances) {
+              const relatedInstancesMap = new Map(
+                relatedInstances.map((inst) => [
+                  inst.id,
+                  transformEntityInstance(inst)
+                ])
+              );
+              for (const relation of allRelations) {
+                const relationField = relationFields.find(
+                  (f) => f.id === relation.relation_field_id
+                );
+                if (relationField) {
+                  const relatedInstance = relatedInstancesMap.get(
+                    relation.target_instance_id
+                  );
+                  if (relatedInstance) {
+                    if (!relations[relationField.name]) {
+                      relations[relationField.name] = [];
+                    }
+                    relations[relationField.name].push(
+                      relatedInstance
+                    );
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      const fileFields = fields.filter(
+        (f) => f.type === "files" || f.type === "images"
+      );
+      if (fileFields.length > 0) {
+        const { data: allFiles, error: filesError } = await this.supabase.from("entity_file").select("id, field_id").eq("entity_instance_id", id);
+        if (filesError) {
+          throw new SDKError(
+            "FILES_LOAD_ERROR",
+            `Failed to load files for instance ${id}: ${filesError.message}`,
+            500,
+            filesError
+          );
+        }
+        if (allFiles) {
+          const filesByFieldId = /* @__PURE__ */ new Map();
+          allFiles.forEach((file) => {
+            if (file.field_id) {
+              if (!filesByFieldId.has(file.field_id)) {
+                filesByFieldId.set(file.field_id, []);
+              }
+              filesByFieldId.get(file.field_id).push(file.id);
+            }
+          });
+          fileFields.forEach((field) => {
+            const fileIds = filesByFieldId.get(field.id) || [];
+            if (fileIds.length > 0 || !transformedInstance.data[field.name]) {
+              transformedInstance.data[field.name] = fileIds;
+            }
+          });
+        }
+      }
+      const instanceWithRelations = __spreadProps(__spreadValues({}, transformedInstance), {
+        relations: Object.keys(relations).length > 0 ? relations : void 0
+      });
+      return flattenInstance(
+        instanceWithRelations,
+        fields.map((f) => ({ name: f.name, dbType: f.dbType })),
+        (_a = params == null ? void 0 : params.relationsAsIds) != null ? _a : false
+      );
+    } catch (error) {
+      if (error instanceof NotFoundError || error instanceof PermissionDeniedError || error instanceof SDKError) {
+        throw error;
+      }
+      handleSupabaseError(error);
+    }
+  }
+  /**
+   * Получить список экземпляров
+   * Поддерживает поиск, фильтры (JSONB и relation), пагинацию
+   */
+  async getInstances(entityDefinitionId, params) {
+    var _a, _b;
+    try {
+      const fields = await this.getFields(entityDefinitionId);
+      const page = (params == null ? void 0 : params.page) || 1;
+      const limit = (params == null ? void 0 : params.limit) || 20;
+      const offset = (page - 1) * limit;
+      const relationFieldsMap = /* @__PURE__ */ new Map();
+      fields.forEach((field) => {
+        if (field.relatedEntityDefinitionId && (field.dbType === "manyToMany" || field.dbType === "manyToOne" || field.dbType === "oneToMany" || field.dbType === "oneToOne")) {
+          relationFieldsMap.set(field.name, { fieldId: field.id });
+        }
+      });
+      const jsonbFilters = {};
+      const relationFiltersToApply = [];
+      if (params == null ? void 0 : params.filters) {
+        Object.entries(params.filters).forEach(([fieldName, values]) => {
+          if (values && values.length > 0) {
+            const relationField = relationFieldsMap.get(fieldName);
+            if (relationField) {
+              relationFiltersToApply.push({
+                fieldName,
+                fieldId: relationField.fieldId,
+                values
+              });
+            } else {
+              jsonbFilters[fieldName] = values;
+            }
+          }
+        });
+      }
+      let allowedInstanceIds = null;
+      if (relationFiltersToApply.length > 0) {
+        const filterModes = (params == null ? void 0 : params.relationFilterModes) || {};
+        const anyModeFilters = [];
+        const allModeFilters = [];
+        relationFiltersToApply.forEach((rf) => {
+          const mode = filterModes[rf.fieldName] || "any";
+          if (mode === "all") {
+            allModeFilters.push(rf);
+          } else {
+            anyModeFilters.push(rf);
+          }
+        });
+        const anyModeInstanceIds = anyModeFilters.length > 0 ? /* @__PURE__ */ new Set() : null;
+        if (anyModeInstanceIds !== null && anyModeFilters.length > 0) {
+          const orConditions = anyModeFilters.flatMap(
+            (rf) => rf.values.map(
+              (targetId) => `and(relation_field_id.eq.${rf.fieldId},target_instance_id.eq.${targetId})`
+            )
+          );
+          const { data: relations, error: relError } = await this.supabase.from("entity_relation").select("source_instance_id").or(orConditions.join(","));
+          if (relError) {
+            throw new SDKError(
+              "RELATION_FILTER_ERROR",
+              `Failed to apply relation filters (any mode): ${relError.message}`,
+              500,
+              relError
+            );
+          } else if (relations) {
+            relations.forEach(
+              (r) => anyModeInstanceIds.add(r.source_instance_id)
+            );
+          }
+        }
+        const allModeInstanceIdSets = [];
+        for (const rf of allModeFilters) {
+          const { data: relations, error: relError } = await this.supabase.from("entity_relation").select("source_instance_id, target_instance_id").eq("relation_field_id", rf.fieldId).in("target_instance_id", rf.values);
+          if (relError) {
+            throw new SDKError(
+              "RELATION_FILTER_ERROR",
+              `Failed to apply relation filters (all mode): ${relError.message}`,
+              500,
+              relError
+            );
+          }
+          if (relations) {
+            const sourceTargetMap = /* @__PURE__ */ new Map();
+            relations.forEach((r) => {
+              if (!sourceTargetMap.has(r.source_instance_id)) {
+                sourceTargetMap.set(r.source_instance_id, /* @__PURE__ */ new Set());
+              }
+              sourceTargetMap.get(r.source_instance_id).add(r.target_instance_id);
+            });
+            const validSources = /* @__PURE__ */ new Set();
+            const requiredTargets = new Set(rf.values);
+            sourceTargetMap.forEach((targets, sourceId) => {
+              const hasAll = [...requiredTargets].every((t) => targets.has(t));
+              if (hasAll) {
+                validSources.add(sourceId);
+              }
+            });
+            allModeInstanceIdSets.push(validSources);
+          }
+        }
+        if (anyModeInstanceIds !== null || allModeInstanceIdSets.length > 0) {
+          if (anyModeInstanceIds !== null && anyModeInstanceIds.size > 0) {
+            allowedInstanceIds = [...anyModeInstanceIds];
+          } else if (allModeInstanceIdSets.length > 0) {
+            allowedInstanceIds = [...allModeInstanceIdSets[0]];
+          }
+          if (allowedInstanceIds !== null && allModeInstanceIdSets.length > 0) {
+            for (const idSet of allModeInstanceIdSets) {
+              allowedInstanceIds = allowedInstanceIds.filter(
+                (id) => idSet.has(id)
+              );
+            }
+          }
+        }
+        if (allowedInstanceIds !== null && allowedInstanceIds.length === 0) {
+          return {
+            data: [],
+            pagination: {
+              page,
+              limit,
+              total: 0,
+              totalPages: 0,
+              hasPreviousPage: false,
+              hasNextPage: false
+            }
+          };
+        }
+      }
+      const searchFields = (() => {
+        const searchable = fields.filter((f) => f.searchable).map((f) => f.name);
+        return searchable.length > 0 ? searchable : ["name"];
+      })();
+      const searchTerm = ((_a = params == null ? void 0 : params.search) == null ? void 0 : _a.trim()) || null;
+      let data = null;
+      let error = null;
+      let count = null;
+      if (searchTerm) {
+        const rpcParams = {
+          p_entity_definition_id: entityDefinitionId,
+          p_project_id: this.projectId,
+          p_search_term: searchTerm,
+          p_search_fields: searchFields,
+          p_limit: limit,
+          p_offset: offset
+        };
+        const { data: rpcData, error: rpcError } = await this.supabase.rpc(
+          "search_entity_instances",
+          rpcParams
+        );
+        if (rpcError) {
+          error = rpcError;
+        } else if (rpcData && rpcData.length > 0) {
+          count = rpcData[0].total_count;
+          data = rpcData;
+        } else {
+          data = [];
+          count = 0;
+        }
+      } else {
+        let query = this.supabase.from("entity_instance").select("*", { count: "exact" }).eq("entity_definition_id", entityDefinitionId).eq("project_id", this.projectId);
+        if (allowedInstanceIds !== null && allowedInstanceIds.length > 0) {
+          query = query.in("id", allowedInstanceIds);
+        }
+        if (Object.keys(jsonbFilters).length > 0) {
+          Object.entries(jsonbFilters).forEach(([fieldName, values]) => {
+            if (values && values.length > 0) {
+              query = query.or(
+                values.map((v) => `data->>${fieldName}.eq.${v}`).join(",")
+              );
+            }
+          });
+        }
+        const sortBy = (params == null ? void 0 : params.sortBy) || "created_at";
+        const sortOrder = (params == null ? void 0 : params.sortOrder) || "desc";
+        query = query.order(sortBy, { ascending: sortOrder === "asc" });
+        query = query.range(offset, offset + limit - 1);
+        const result = await query;
+        data = result.data;
+        error = result.error;
+        count = result.count;
+      }
+      if (error) {
+        handleSupabaseError(error);
+      }
+      if (!data || data.length === 0) {
+        return {
+          data: [],
+          pagination: {
+            page,
+            limit,
+            total: count || 0,
+            totalPages: Math.ceil((count || 0) / limit),
+            hasPreviousPage: page > 1,
+            hasNextPage: page < Math.ceil((count || 0) / limit)
+          }
+        };
+      }
+      const transformedInstances = data.map(transformEntityInstance);
+      const relationsMap = /* @__PURE__ */ new Map();
+      const relationFieldsToLoad = fields.filter(
+        (f) => f.relatedEntityDefinitionId && (f.dbType === "manyToMany" || f.dbType === "manyToOne" || f.dbType === "oneToMany" || f.dbType === "oneToOne") && f.displayInTable
+      ).map((f) => f.name);
+      if (relationFieldsToLoad.length > 0 && transformedInstances.length > 0) {
+        const relationFields = relationFieldsToLoad.map((fieldName) => {
+          const field = fields.find(
+            (f) => f.name === fieldName && (f.dbType === "manyToMany" || f.dbType === "manyToOne" || f.dbType === "oneToMany" || f.dbType === "oneToOne")
+          );
+          return field ? { name: fieldName, field } : null;
+        }).filter(
+          (f) => f !== null
+        );
+        if (relationFields.length > 0) {
+          const instanceIds = transformedInstances.map((inst) => inst.id);
+          const relationFieldIds = relationFields.map((rf) => rf.field.id);
+          const { data: relationsWithInstances, error: rpcError } = await this.supabase.rpc(
+            "get_related_instances",
+            {
+              p_source_instance_ids: instanceIds,
+              p_relation_field_ids: relationFieldIds
+            }
+          );
+          if (rpcError) {
+            throw new SDKError(
+              "RELATIONS_LOAD_ERROR",
+              `Failed to load relations with instances: ${rpcError.message}`,
+              500,
+              rpcError
+            );
+          }
+          if (relationsWithInstances && relationsWithInstances.length > 0) {
+            const relatedInstancesMap = new Map(
+              relationsWithInstances.map((row) => [
+                row.target_instance_id,
+                transformEntityInstance({
+                  id: row.target_instance_id,
+                  entity_definition_id: row.target_entity_definition_id,
+                  project_id: row.target_project_id,
+                  data: row.target_data,
+                  created_at: row.target_created_at,
+                  updated_at: row.target_updated_at
+                })
+              ])
+            );
+            const targetEntityDefinitionIds = [
+              ...new Set(
+                Array.from(relatedInstancesMap.values()).map(
+                  (inst) => inst.entityDefinitionId
+                )
+              )
+            ];
+            const fieldsMap = /* @__PURE__ */ new Map();
+            await Promise.all(
+              targetEntityDefinitionIds.map(async (entityDefId) => {
+                const targetFields = await this.getFields(entityDefId);
+                fieldsMap.set(
+                  entityDefId,
+                  targetFields.map((f) => ({
+                    name: f.name,
+                    dbType: f.dbType
+                  }))
+                );
+              })
+            );
+            for (const relationRow of relationsWithInstances) {
+              const instanceId = relationRow.source_instance_id;
+              const relationField = relationFields.find(
+                (rf) => rf.field.id === relationRow.relation_field_id
+              );
+              if (relationField) {
+                const relatedInstance = relatedInstancesMap.get(
+                  relationRow.target_instance_id
+                );
+                if (relatedInstance) {
+                  if (!relationsMap.has(instanceId)) {
+                    relationsMap.set(instanceId, {});
+                  }
+                  const instanceRelations = relationsMap.get(instanceId);
+                  if (!instanceRelations[relationField.name]) {
+                    instanceRelations[relationField.name] = [];
+                  }
+                  const targetFields = fieldsMap.get(relatedInstance.entityDefinitionId) || [];
+                  const flattenedRelated = flattenInstance(
+                    relatedInstance,
+                    targetFields,
+                    (_b = params == null ? void 0 : params.relationsAsIds) != null ? _b : false
+                  );
+                  instanceRelations[relationField.name].push(flattenedRelated);
+                }
+              }
+            }
+          }
+        }
+      }
+      const fileFields = fields.filter(
+        (f) => f.type === "files" || f.type === "images"
+      );
+      if (fileFields.length > 0 && transformedInstances.length > 0) {
+        const instanceIds = transformedInstances.map((inst) => inst.id);
+        const fieldIds = fileFields.map((f) => f.id);
+        const { data: allFiles, error: filesError } = await this.supabase.from("entity_file").select("id, entity_instance_id, field_id").in("entity_instance_id", instanceIds).in("field_id", fieldIds);
+        if (filesError) {
+          throw new SDKError(
+            "FILES_LOAD_ERROR",
+            `Failed to load files: ${filesError.message}`,
+            500,
+            filesError
+          );
+        }
+        if (allFiles) {
+          const filesMap = /* @__PURE__ */ new Map();
+          allFiles.forEach((file) => {
+            if (file.field_id) {
+              if (!filesMap.has(file.entity_instance_id)) {
+                filesMap.set(file.entity_instance_id, /* @__PURE__ */ new Map());
+              }
+              const instanceFiles = filesMap.get(file.entity_instance_id);
+              if (!instanceFiles.has(file.field_id)) {
+                instanceFiles.set(file.field_id, []);
+              }
+              instanceFiles.get(file.field_id).push(file.id);
+            }
+          });
+          transformedInstances.forEach((instance) => {
+            const instanceFiles = filesMap.get(instance.id);
+            if (instanceFiles) {
+              fileFields.forEach((field) => {
+                const fileIds = instanceFiles.get(field.id) || [];
+                if (fileIds.length > 0 || !instance.data[field.name]) {
+                  instance.data[field.name] = fileIds;
+                }
+              });
+            }
+          });
+        }
+      }
+      const instancesWithRelations = transformedInstances.map((instance) => {
+        const instanceRelations = relationsMap.get(instance.id) || {};
+        return __spreadProps(__spreadValues({}, instance), {
+          relations: Object.keys(instanceRelations).length > 0 ? instanceRelations : void 0
+        });
+      });
+      const flattenedInstances = instancesWithRelations.map(
+        (inst) => {
+          var _a2;
+          return flattenInstance(
+            inst,
+            fields.map((f) => ({ name: f.name, dbType: f.dbType })),
+            (_a2 = params == null ? void 0 : params.relationsAsIds) != null ? _a2 : false
+          );
+        }
+      );
+      const total = count || 0;
+      const totalPages = Math.ceil(total / limit);
+      return {
+        data: flattenedInstances,
+        pagination: {
+          page,
+          limit,
+          total,
+          totalPages,
+          hasPreviousPage: page > 1,
+          hasNextPage: page < totalPages
+        }
+      };
+    } catch (error) {
+      if (error instanceof NotFoundError || error instanceof PermissionDeniedError || error instanceof SDKError) {
+        throw error;
+      }
+      handleSupabaseError(error);
+    }
+  }
+  /**
+   * Создать экземпляр сущности
+   * Поддерживает создание с relations и автоматически устанавливает created_by
+   */
+  async createInstance(entityDefinitionId, data) {
+    try {
+      const fields = await this.getFields(entityDefinitionId);
+      const {
+        data: { user },
+        error: userError
+      } = await this.supabase.auth.getUser();
+      if (userError) {
+        console.warn(
+          "[SDK] Could not get user for created_by:",
+          userError.message
+        );
+      }
+      const { data: instanceData, relations } = data;
+      const { data: instance, error: instanceError } = await this.supabase.from("entity_instance").insert({
+        entity_definition_id: entityDefinitionId,
+        project_id: this.projectId,
+        data: instanceData,
+        created_by: (user == null ? void 0 : user.id) || null
+      }).select().single();
+      if (instanceError || !instance) {
+        handleInstanceError(
+          instanceError || new Error("Failed to create instance"),
+          "new"
+        );
+      }
+      const transformedInstance = transformEntityInstance(instance);
+      if (relations && Object.keys(relations).length > 0) {
+        const relationFields = fields.filter(
+          (f) => f.dbType === "manyToMany" || f.dbType === "manyToOne" || f.dbType === "oneToMany" || f.dbType === "oneToOne"
+        );
+        const relationInserts = [];
+        for (const [fieldName, targetInstanceIds] of Object.entries(
+          relations
+        )) {
+          const field = relationFields.find((f) => f.name === fieldName);
+          if (!field) {
+            console.warn(
+              `[SDK] Field ${fieldName} not found or not a relation field`
+            );
+            continue;
+          }
+          const ids = Array.isArray(targetInstanceIds) ? targetInstanceIds : targetInstanceIds ? [targetInstanceIds] : [];
+          for (const targetInstanceId of ids) {
+            if (targetInstanceId) {
+              relationInserts.push({
+                source_instance_id: transformedInstance.id,
+                target_instance_id: targetInstanceId,
+                relation_field_id: field.id,
+                relation_type: field.dbType
+              });
+            }
+          }
+        }
+        if (relationInserts.length > 0) {
+          const { error: relationsError } = await this.supabase.from("entity_relation").insert(relationInserts);
+          if (relationsError) {
+            throw new SDKError(
+              "RELATIONS_CREATE_ERROR",
+              `Failed to create relations: ${relationsError.message}`,
+              500,
+              relationsError
+            );
+          }
+        }
+      }
+      return await this.getInstance(entityDefinitionId, transformedInstance.id);
+    } catch (error) {
+      if (error instanceof NotFoundError || error instanceof PermissionDeniedError || error instanceof SDKError) {
+        throw error;
+      }
+      handleSupabaseError(error);
+    }
+  }
+  async updateInstance(entityDefinitionId, id, data) {
+    try {
+      const { data: currentInstance, error: checkError } = await this.supabase.from("entity_instance").select("id, data, entity_definition_id, project_id").eq("id", id).eq("entity_definition_id", entityDefinitionId).eq("project_id", this.projectId).single();
+      if (checkError || !currentInstance) {
+        handleInstanceError(checkError || new Error("Instance not found"), id);
+      }
+      const fields = await this.getFields(entityDefinitionId);
+      const { data: instanceData, relations } = data;
+      const updatedData = __spreadValues(__spreadValues({}, currentInstance.data || {}), instanceData);
+      const { data: updated, error: updateError } = await this.supabase.from("entity_instance").update({
+        data: updatedData,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      }).eq("id", id).eq("entity_definition_id", entityDefinitionId).eq("project_id", this.projectId).select().single();
+      if (updateError || !updated) {
+        throw new SDKError(
+          "UPDATE_ERROR",
+          `Failed to update entity instance: ${(updateError == null ? void 0 : updateError.message) || "Update failed"}`,
+          500,
+          updateError
+        );
+      }
+      if (relations && Object.keys(relations).length > 0) {
+        const relationFields = fields.filter(
+          (f) => f.dbType === "manyToMany" || f.dbType === "manyToOne" || f.dbType === "oneToMany" || f.dbType === "oneToOne"
+        );
+        const fieldIds = Object.keys(relations).map((fieldName) => {
+          const field = relationFields.find((f) => f.name === fieldName);
+          return field == null ? void 0 : field.id;
+        }).filter(Boolean);
+        if (fieldIds.length > 0) {
+          const { error: deleteError } = await this.supabase.from("entity_relation").delete().eq("source_instance_id", id).in("relation_field_id", fieldIds);
+          if (deleteError) {
+            throw new SDKError(
+              "RELATIONS_DELETE_ERROR",
+              `Failed to delete old relations: ${deleteError.message}`,
+              500,
+              deleteError
+            );
+          }
+        }
+        const relationInserts = [];
+        for (const [fieldName, targetInstanceIds] of Object.entries(
+          relations
+        )) {
+          const field = relationFields.find((f) => f.name === fieldName);
+          if (!field) {
+            console.warn(
+              `[SDK] Field ${fieldName} not found or not a relation field`
+            );
+            continue;
+          }
+          const ids = Array.isArray(targetInstanceIds) ? targetInstanceIds : targetInstanceIds ? [targetInstanceIds] : [];
+          for (const targetInstanceId of ids) {
+            if (targetInstanceId) {
+              relationInserts.push({
+                source_instance_id: id,
+                target_instance_id: targetInstanceId,
+                relation_field_id: field.id,
+                relation_type: field.dbType
+              });
+            }
+          }
+        }
+        if (relationInserts.length > 0) {
+          const { error: relationsError } = await this.supabase.from("entity_relation").insert(relationInserts);
+          if (relationsError) {
+            throw new SDKError(
+              "RELATIONS_CREATE_ERROR",
+              `Failed to create relations: ${relationsError.message}`,
+              500,
+              relationsError
+            );
+          }
+        }
+      }
+      return await this.buildUpdatedInstance(updated, fields, relations || {});
+    } catch (error) {
+      if (error instanceof NotFoundError || error instanceof PermissionDeniedError || error instanceof SDKError) {
+        throw error;
+      }
+      handleSupabaseError(error);
+    }
+  }
+  /**
+   * Формирует обновленный экземпляр из уже обновленных данных без повторной загрузки
+   * Оптимизация: избегает лишних запросов после updateInstance
+   * Загружает полные объекты relations для совместимости с форматом списка
+   */
+  async buildUpdatedInstance(updated, fields, relations) {
+    const transformedInstance = transformEntityInstance(updated);
+    const relationsMap = {};
+    if (Object.keys(relations).length > 0) {
+      const relationFields = fields.filter(
+        (f) => f.dbType === "manyToMany" || f.dbType === "manyToOne" || f.dbType === "oneToMany" || f.dbType === "oneToOne"
+      );
+      const allTargetInstanceIds = [
+        ...new Set(
+          Object.values(relations).flatMap(
+            (ids) => Array.isArray(ids) ? ids : [ids]
+          )
+        )
+      ].filter(Boolean);
+      if (allTargetInstanceIds.length > 0) {
+        const { data: relatedInstances, error: instancesError } = await this.supabase.from("entity_instance").select("*").in("id", allTargetInstanceIds);
+        if (instancesError) {
+          console.warn(
+            "[SDK] Failed to load related instances for buildUpdatedInstance:",
+            instancesError.message
+          );
+        } else if (relatedInstances) {
+          const relatedInstancesMap = new Map(
+            relatedInstances.map((inst) => [
+              inst.id,
+              transformEntityInstance(inst)
+            ])
+          );
+          const targetEntityDefinitionIds = [
+            ...new Set(
+              Array.from(relatedInstancesMap.values()).map(
+                (inst) => inst.entityDefinitionId
+              )
+            )
+          ];
+          const fieldsMap = /* @__PURE__ */ new Map();
+          await Promise.all(
+            targetEntityDefinitionIds.map(async (entityDefId) => {
+              const targetFields = await this.getFields(entityDefId);
+              fieldsMap.set(
+                entityDefId,
+                targetFields.map((f) => ({
+                  name: f.name,
+                  dbType: f.dbType
+                }))
+              );
+            })
+          );
+          for (const [fieldName, targetInstanceIds] of Object.entries(
+            relations
+          )) {
+            const field = relationFields.find((f) => f.name === fieldName);
+            if (field) {
+              const ids = Array.isArray(targetInstanceIds) ? targetInstanceIds : targetInstanceIds ? [targetInstanceIds] : [];
+              const relatedInstancesForField = [];
+              for (const id of ids) {
+                const relatedInstance = relatedInstancesMap.get(id);
+                if (relatedInstance) {
+                  const targetFields = fieldsMap.get(relatedInstance.entityDefinitionId) || [];
+                  const flattenedRelated = flattenInstance(
+                    relatedInstance,
+                    targetFields,
+                    false
+                    // relationsAsIds = false для совместимости со списком
+                  );
+                  relatedInstancesForField.push(flattenedRelated);
+                }
+              }
+              if (relatedInstancesForField.length > 0) {
+                relationsMap[fieldName] = relatedInstancesForField;
+              }
+            }
+          }
+        }
+      }
+    }
+    const instanceWithRelations = __spreadProps(__spreadValues({}, transformedInstance), {
+      relations: Object.keys(relationsMap).length > 0 ? relationsMap : void 0
+    });
+    return flattenInstance(
+      instanceWithRelations,
+      fields.map((f) => ({ name: f.name, dbType: f.dbType })),
+      false
+      // relationsAsIds = false - возвращаем полные объекты как в списке
+    );
+  }
+  /**
+   * Удалить экземпляр сущности
+   * Связи удалятся автоматически через ON DELETE CASCADE
+   */
+  async deleteInstance(entityDefinitionId, id) {
+    try {
+      const { data: instance, error: checkError } = await this.supabase.from("entity_instance").select("id, entity_definition_id, project_id").eq("id", id).eq("entity_definition_id", entityDefinitionId).eq("project_id", this.projectId).single();
+      if (checkError || !instance) {
+        handleInstanceError(checkError || new Error("Instance not found"), id);
+      }
+      const { error: deleteError } = await this.supabase.from("entity_instance").delete().eq("id", id).eq("entity_definition_id", entityDefinitionId).eq("project_id", this.projectId);
+      if (deleteError) {
+        throw new SDKError(
+          "DELETE_ERROR",
+          `Failed to delete entity instance: ${deleteError.message}`,
+          500,
+          deleteError
+        );
+      }
+    } catch (error) {
+      if (error instanceof NotFoundError || error instanceof PermissionDeniedError || error instanceof SDKError) {
+        throw error;
+      }
+      handleSupabaseError(error);
+    }
+  }
+  async signIn(email, password) {
+    throw new Error("signIn: Not implemented yet");
+  }
+  async signUp(data) {
+    throw new Error("signUp: Not implemented yet");
+  }
+  async signOut() {
+    throw new Error("signOut: Not implemented yet");
+  }
+  async getCurrentUser() {
+    throw new Error("getCurrentUser: Not implemented yet");
+  }
+};
+_PublicAPIClient.instances = /* @__PURE__ */ new Map();
+var PublicAPIClient = _PublicAPIClient;
+
+// src/browser.ts
+function createClientSDK(projectId, config, options) {
+  const supabase = createBrowserClient(
+    config.supabaseUrl,
+    config.supabaseAnonKey
+  );
+  return PublicAPIClient.create(supabase, projectId, "client", options);
+}
+
+exports.AuthenticationError = AuthenticationError;
+exports.NotFoundError = NotFoundError;
+exports.PermissionDeniedError = PermissionDeniedError;
+exports.PublicAPIClient = PublicAPIClient;
+exports.SDKError = SDKError;
+exports.ValidationError = ValidationError;
+exports.createClientSDK = createClientSDK;
+exports.generateUIConfig = generateUIConfig;
+exports.getColumnsFromFields = getColumnsFromFields;
+exports.getFieldValue = getFieldValue;
+exports.handleInstanceError = handleInstanceError;
+exports.handleSupabaseError = handleSupabaseError;
+exports.isEntityData = isEntityData;
+exports.isFieldValue = isFieldValue;
+exports.normalizeFieldValue = normalizeFieldValue;
+exports.toCamelCase = toCamelCase;
+exports.toSnakeCase = toSnakeCase;
+exports.validateInstanceData = validateInstanceData;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map