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

package/dist/index.js

@@ -0,0 +1,318 @@
+// 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
+import { C3Decorator } from "@kinotic-ai/idl";
+
+class EntityServiceDecorator extends C3Decorator {
+}
+// packages/persistence/src/api/idl/EntityServiceDecoratorsDecorator.ts
+import { C3Decorator as C3Decorator2 } from "@kinotic-ai/idl";
+
+class EntityServiceDecoratorsDecorator extends C3Decorator2 {
+  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
+import {
+  FunctionalIterablePage
+} from "@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 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 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 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
+import {
+  FunctionalIterablePage as FunctionalIterablePage2
+} from "@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 FunctionalIterablePage2(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 FunctionalIterablePage2(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 FunctionalIterablePage2(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
+import { Kinotic } from "@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(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
+import { Kinotic as Kinotic2 } from "@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(Kinotic2);
+  }
+  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
+import { Kinotic as Kinotic3, KinoticSingleton } from "@kinotic-ai/core";
+export {
+  TenantSpecificId,
+  QueryOptions,
+  PrecisionType,
+  PersistencePlugin,
+  MultiTenancyType,
+  KinoticSingleton,
+  Kinotic3 as Kinotic,
+  EsIndexConfigurationData,
+  EntityType,
+  EntityServiceDecoratorsDecorator,
+  EntityServiceDecorator,
+  EntityService,
+  EntitiesService,
+  AdminEntityService,
+  AdminEntitiesService
+};

package/package.json

@@ -1,6 +1,5 @@
 {
   "name": "@kinotic-ai/persistence",
-  "version": "1.0.0-beta.0",
   "type": "module",
   "files": [
     "dist"
@@ -50,5 +49,6 @@
     "typescript": {
       "optional": true
     }
-  }
+  },
+  "version": "1.0.0-beta.1"
 }