@kinotic-ai/persistence 1.0.0-beta.0 → 1.0.0-beta.1

package/dist/index.cjs

@@ -0,0 +1,357 @@
+var import_node_module = require("node:module");
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// packages/persistence/src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  TenantSpecificId: () => TenantSpecificId,
+  QueryOptions: () => QueryOptions,
+  PrecisionType: () => PrecisionType,
+  PersistencePlugin: () => PersistencePlugin,
+  MultiTenancyType: () => MultiTenancyType,
+  KinoticSingleton: () => import_core5.KinoticSingleton,
+  Kinotic: () => import_core5.Kinotic,
+  EsIndexConfigurationData: () => EsIndexConfigurationData,
+  EntityType: () => EntityType,
+  EntityServiceDecoratorsDecorator: () => EntityServiceDecoratorsDecorator,
+  EntityServiceDecorator: () => EntityServiceDecorator,
+  EntityService: () => EntityService,
+  EntitiesService: () => EntitiesService,
+  AdminEntityService: () => AdminEntityService,
+  AdminEntitiesService: () => AdminEntitiesService
+});
+module.exports = __toCommonJS(exports_src);
+
+// packages/persistence/src/api/model/QueryOptions.ts
+class QueryOptions {
+  timeZone;
+  requestTimeout;
+  pageTimeout;
+}
+// packages/persistence/src/api/model/TenantSpecificId.ts
+class TenantSpecificId {
+  entityId;
+  tenantId;
+  constructor(entityId, tenantId) {
+    this.entityId = entityId;
+    this.tenantId = tenantId;
+  }
+}
+// packages/persistence/src/api/idl/EntityServiceDecorator.ts
+var import_idl = require("@kinotic-ai/idl");
+
+class EntityServiceDecorator extends import_idl.C3Decorator {
+}
+// packages/persistence/src/api/idl/EntityServiceDecoratorsDecorator.ts
+var import_idl2 = require("@kinotic-ai/idl");
+
+class EntityServiceDecoratorsDecorator extends import_idl2.C3Decorator {
+  config;
+  constructor() {
+    super();
+    this.type = "EntityServiceDecoratorsDecorator";
+  }
+}
+// packages/persistence/src/api/idl/EntityType.ts
+var EntityType;
+((EntityType2) => {
+  EntityType2[EntityType2["TABLE"] = 0] = "TABLE";
+  EntityType2[EntityType2["STREAM"] = 1] = "STREAM";
+})(EntityType ||= {});
+// packages/persistence/src/api/idl/EsIndexConfigurationData.ts
+class EsIndexConfigurationData {
+  componentTemplates = [];
+}
+// packages/persistence/src/api/idl/MultiTenancyType.ts
+var MultiTenancyType;
+((MultiTenancyType2) => {
+  MultiTenancyType2[MultiTenancyType2["NONE"] = 0] = "NONE";
+  MultiTenancyType2[MultiTenancyType2["SHARED"] = 1] = "SHARED";
+})(MultiTenancyType ||= {});
+// packages/persistence/src/api/idl/PrecisionType.ts
+var PrecisionType;
+((PrecisionType2) => {
+  PrecisionType2[PrecisionType2["DOUBLE"] = 0] = "DOUBLE";
+  PrecisionType2[PrecisionType2["FLOAT"] = 1] = "FLOAT";
+  PrecisionType2[PrecisionType2["INT"] = 2] = "INT";
+  PrecisionType2[PrecisionType2["LONG"] = 3] = "LONG";
+  PrecisionType2[PrecisionType2["SHORT"] = 4] = "SHORT";
+})(PrecisionType ||= {});
+// packages/persistence/src/api/IEntitiesService.ts
+var import_core = require("@kinotic-ai/core");
+
+class EntitiesService {
+  serviceProxy;
+  constructor(kinotic) {
+    this.serviceProxy = kinotic.serviceProxy("org.kinotic.persistence.api.services.JsonEntitiesService");
+  }
+  bulkSave(structureId, entities) {
+    return this.serviceProxy.invoke("bulkSave", [structureId, entities]);
+  }
+  bulkUpdate(structureId, entities) {
+    return this.serviceProxy.invoke("bulkUpdate", [structureId, entities]);
+  }
+  count(structureId) {
+    return this.serviceProxy.invoke("count", [structureId]);
+  }
+  countByQuery(structureId, query) {
+    return this.serviceProxy.invoke("countByQuery", [structureId, query]);
+  }
+  deleteById(structureId, id) {
+    return this.serviceProxy.invoke("deleteById", [structureId, id]);
+  }
+  deleteByQuery(structureId, query) {
+    return this.serviceProxy.invoke("deleteByQuery", [structureId, query]);
+  }
+  async findAll(structureId, pageable) {
+    const page = await this.findAllSinglePage(structureId, pageable);
+    return new import_core.FunctionalIterablePage(pageable, page, (pageable2) => this.findAllSinglePage(structureId, pageable2));
+  }
+  async findAllSinglePage(structureId, pageable) {
+    return this.serviceProxy.invoke("findAll", [structureId, pageable]);
+  }
+  findById(structureId, id) {
+    return this.serviceProxy.invoke("findById", [structureId, id]);
+  }
+  findByIds(structureId, ids) {
+    return this.serviceProxy.invoke("findByIds", [structureId, ids]);
+  }
+  namedQuery(structureId, queryName, parameters) {
+    return this.serviceProxy.invoke("namedQuery", [structureId, queryName, parameters]);
+  }
+  async namedQueryPage(structureId, queryName, parameters, pageable) {
+    const page = await this.namedQuerySinglePage(structureId, queryName, parameters, pageable);
+    return new import_core.FunctionalIterablePage(pageable, page, (pageable2) => this.namedQuerySinglePage(structureId, queryName, parameters, pageable2));
+  }
+  namedQuerySinglePage(structureId, queryName, parameters, pageable) {
+    return this.serviceProxy.invoke("namedQueryPage", [structureId, queryName, parameters, pageable]);
+  }
+  save(structureId, entity) {
+    return this.serviceProxy.invoke("save", [structureId, entity]);
+  }
+  async search(structureId, searchText, pageable) {
+    const page = await this.searchSinglePage(structureId, searchText, pageable);
+    return new import_core.FunctionalIterablePage(pageable, page, (pageable2) => this.searchSinglePage(structureId, searchText, pageable2));
+  }
+  async searchSinglePage(structureId, searchText, pageable) {
+    return this.serviceProxy.invoke("search", [structureId, searchText, pageable]);
+  }
+  async syncIndex(structureId) {
+    return this.serviceProxy.invoke("syncIndex", [structureId]);
+  }
+  update(structureId, entity) {
+    return this.serviceProxy.invoke("update", [structureId, entity]);
+  }
+}
+// packages/persistence/src/api/IAdminEntitiesService.ts
+var import_core2 = require("@kinotic-ai/core");
+
+class AdminEntitiesService {
+  serviceProxy;
+  constructor(kinotic) {
+    this.serviceProxy = kinotic.serviceProxy("org.kinotic.persistence.api.services.AdminJsonEntitiesService");
+  }
+  count(structureId, tenantSelection) {
+    return this.serviceProxy.invoke("count", [structureId, tenantSelection]);
+  }
+  countByQuery(structureId, query, tenantSelection) {
+    return this.serviceProxy.invoke("countByQuery", [structureId, query, tenantSelection]);
+  }
+  deleteById(structureId, id) {
+    return this.serviceProxy.invoke("deleteById", [structureId, id]);
+  }
+  deleteByQuery(structureId, query, tenantSelection) {
+    return this.serviceProxy.invoke("deleteByQuery", [structureId, query, tenantSelection]);
+  }
+  async findAll(structureId, tenantSelection, pageable) {
+    const page = await this.findAllSinglePage(structureId, tenantSelection, pageable);
+    return new import_core2.FunctionalIterablePage(pageable, page, (pageable2) => this.findAllSinglePage(structureId, tenantSelection, pageable2));
+  }
+  async findAllSinglePage(structureId, tenantSelection, pageable) {
+    return this.serviceProxy.invoke("findAll", [structureId, tenantSelection, pageable]);
+  }
+  findById(structureId, id) {
+    return this.serviceProxy.invoke("findById", [structureId, id]);
+  }
+  findByIds(structureId, ids) {
+    return this.serviceProxy.invoke("findByIds", [structureId, ids]);
+  }
+  namedQuery(structureId, queryName, parameters) {
+    return this.serviceProxy.invoke("namedQuery", [structureId, queryName, parameters]);
+  }
+  async namedQueryPage(structureId, queryName, parameters, pageable) {
+    const page = await this.namedQuerySinglePage(structureId, queryName, parameters, pageable);
+    return new import_core2.FunctionalIterablePage(pageable, page, (pageable2) => this.namedQuerySinglePage(structureId, queryName, parameters, pageable2));
+  }
+  namedQuerySinglePage(structureId, queryName, parameters, pageable) {
+    return this.serviceProxy.invoke("namedQueryPage", [structureId, queryName, parameters, pageable]);
+  }
+  async search(structureId, searchText, tenantSelection, pageable) {
+    const page = await this.searchSinglePage(structureId, searchText, tenantSelection, pageable);
+    return new import_core2.FunctionalIterablePage(pageable, page, (pageable2) => this.searchSinglePage(structureId, searchText, tenantSelection, pageable2));
+  }
+  async searchSinglePage(structureId, searchText, tenantSelection, pageable) {
+    return this.serviceProxy.invoke("search", [structureId, searchText, tenantSelection, pageable]);
+  }
+}
+// packages/persistence/src/api/IEntityService.ts
+var import_core3 = require("@kinotic-ai/core");
+class EntityService {
+  structureApplicationId;
+  structureName;
+  structureId;
+  entitiesService;
+  constructor(structureApplicationId, structureName, entitiesService) {
+    this.structureApplicationId = structureApplicationId;
+    this.structureName = structureName;
+    this.structureId = (structureApplicationId + "." + structureName).toLowerCase();
+    this.entitiesService = entitiesService ?? new EntitiesService(import_core3.Kinotic);
+  }
+  async bulkSave(entities) {
+    const entitiesToSave = await this.beforeBulkSaveOrUpdate(entities);
+    return this.entitiesService.bulkSave(this.structureId, entitiesToSave);
+  }
+  async bulkUpdate(entities) {
+    const entitiesToSave = await this.beforeBulkSaveOrUpdate(entities);
+    return this.entitiesService.bulkUpdate(this.structureId, entitiesToSave);
+  }
+  count() {
+    return this.entitiesService.count(this.structureId);
+  }
+  countByQuery(query) {
+    return this.entitiesService.countByQuery(this.structureId, query);
+  }
+  deleteById(id) {
+    return this.entitiesService.deleteById(this.structureId, id);
+  }
+  deleteByQuery(query) {
+    return this.entitiesService.deleteByQuery(this.structureId, query);
+  }
+  findAll(pageable) {
+    return this.entitiesService.findAll(this.structureId, pageable);
+  }
+  findById(id) {
+    return this.entitiesService.findById(this.structureId, id);
+  }
+  findByIds(ids) {
+    return this.entitiesService.findByIds(this.structureId, ids);
+  }
+  namedQuery(queryName, queryParameters) {
+    return this.entitiesService.namedQuery(this.structureId, queryName, queryParameters);
+  }
+  namedQueryPage(queryName, queryParameters, pageable) {
+    return this.entitiesService.namedQueryPage(this.structureId, queryName, queryParameters, pageable);
+  }
+  async save(entity) {
+    const entityToSave = await this.beforeSaveOrUpdate(entity);
+    return this.entitiesService.save(this.structureId, entityToSave);
+  }
+  search(searchText, pageable) {
+    return this.entitiesService.search(this.structureId, searchText, pageable);
+  }
+  async syncIndex() {
+    return this.entitiesService.syncIndex(this.structureId);
+  }
+  async update(entity) {
+    const entityToSave = await this.beforeSaveOrUpdate(entity);
+    return this.entitiesService.update(this.structureId, entityToSave);
+  }
+  async beforeBulkSaveOrUpdate(entities) {
+    return Promise.resolve(entities);
+  }
+  async beforeSaveOrUpdate(entity) {
+    return Promise.resolve(entity);
+  }
+}
+// packages/persistence/src/api/IAdminEntityService.ts
+var import_core4 = require("@kinotic-ai/core");
+class AdminEntityService {
+  structureApplicationId;
+  structureName;
+  structureId;
+  adminEntitiesService;
+  constructor(structureApplicationId, structureName, adminEntitiesService) {
+    this.structureApplicationId = structureApplicationId;
+    this.structureName = structureName;
+    this.structureId = (structureApplicationId + "." + structureName).toLowerCase();
+    this.adminEntitiesService = adminEntitiesService ?? new AdminEntitiesService(import_core4.Kinotic);
+  }
+  count(tenantSelection) {
+    return this.adminEntitiesService.count(this.structureId, tenantSelection);
+  }
+  countByQuery(query, tenantSelection) {
+    return this.adminEntitiesService.countByQuery(this.structureId, query, tenantSelection);
+  }
+  deleteById(id) {
+    return this.adminEntitiesService.deleteById(this.structureId, id);
+  }
+  deleteByQuery(query, tenantSelection) {
+    return this.adminEntitiesService.deleteByQuery(this.structureId, query, tenantSelection);
+  }
+  findAll(tenantSelection, pageable) {
+    return this.adminEntitiesService.findAll(this.structureId, tenantSelection, pageable);
+  }
+  findById(id) {
+    return this.adminEntitiesService.findById(this.structureId, id);
+  }
+  findByIds(ids) {
+    return this.adminEntitiesService.findByIds(this.structureId, ids);
+  }
+  namedQuery(queryName, queryParameters) {
+    return this.adminEntitiesService.namedQuery(this.structureId, queryName, queryParameters);
+  }
+  namedQueryPage(queryName, queryParameters, pageable) {
+    return this.adminEntitiesService.namedQueryPage(this.structureId, queryName, queryParameters, pageable);
+  }
+  search(searchText, tenantSelection, pageable) {
+    return this.adminEntitiesService.search(this.structureId, searchText, tenantSelection, pageable);
+  }
+}
+// packages/persistence/src/api/PersistencePlugin.ts
+var PersistencePlugin = {
+  install(kinotic) {
+    return {
+      entities: new EntitiesService(kinotic),
+      adminEntities: new AdminEntitiesService(kinotic)
+    };
+  }
+};
+
+// packages/persistence/src/index.ts
+var import_core5 = require("@kinotic-ai/core");