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

package/README.md

@@ -0,0 +1,65 @@
+# @kinotic-ai/persistence
+
+Instant, schema-driven data access for your Kinotic applications. `@kinotic-ai/persistence` eliminates the data layer boilerplate that slows every project down — define your entity once and get full CRUD, full-text search, pagination, bulk operations, and named queries without writing a single query or mapping file. It is designed for developers who want enterprise-grade data capabilities without the infrastructure overhead.
+
+**[Get started at kinotic.ai/getting-started](https://kinotic.ai/getting-started)**
+
+---
+
+## Why @kinotic-ai/persistence?
+
+- **Zero query boilerplate.** Decorate your TypeScript classes and the data layer is ready — no mappers, no repositories, no hand-written queries to maintain.
+- **Search is a first-class feature.** Full-text search across your data is available immediately, as naturally as any other read operation.
+- **Built for scale.** Pagination, bulk operations, and cursor-based traversal handle large datasets without architectural changes.
+- **Multi-tenancy handled for you.** Data isolation between tenants is automatic — your application logic stays clean.
+- **One line to activate.** Plugs directly into your existing Kinotic connection. No separate configuration, no extra infrastructure.
+
+---
+
+## Features
+
+### Decorator-Driven Entity Definition
+Annotate your TypeScript classes with decorators from this package to define entities — ID generation, indexing behavior, precision, multi-tenancy, access policies, and more. Once decorated, the full data access layer — reads, writes, deletes, and queries — is available immediately. No separate schema files, no mapping layer to write or maintain.
+
+### Full CRUD and Bulk Operations
+Create, read, update, and delete individual records or entire batches with a consistent API. Bulk operations are designed for high-throughput scenarios without special-casing.
+
+### Full-Text Search
+Query your data with powerful full-text search out of the box. No separate search infrastructure required — it comes with the persistence layer.
+
+### Flexible Pagination
+Retrieve large result sets with both offset-based and cursor-based pagination. Switch between styles depending on the use case without changing your data model.
+
+### Named and Reusable Queries
+Define complex queries once, give them a name, and reuse them across your application. Query definitions are first-class citizens, not one-off strings scattered through your code.
+
+### Multi-Tenancy and Data Isolation
+Tenant boundaries are enforced automatically. Data from one tenant never leaks into another — no conditional filters to add, no policies to wire up manually.
+
+### Optimistic Locking
+Concurrent writes are safe by default. Optimistic locking prevents silent data conflicts without requiring pessimistic locks or complex transaction management.
+
+---
+
+## Part of the Kinotic Ecosystem
+
+`@kinotic-ai/persistence` sits in the middle of the Kinotic JavaScript/TypeScript stack:
+
+```
+@kinotic-ai/os-api      ← cloud OS management
+@kinotic-ai/persistence ← schema-driven data access (this package)
+@kinotic-ai/idl         ← cross-language type schemas
+@kinotic-ai/core        ← connection & transport
+```
+
+It depends on `@kinotic-ai/core` for the platform connection and `@kinotic-ai/idl` for schema definitions. `@kinotic-ai/os-api` builds on top of it to provide full cloud OS management.
+
+---
+
+## Installation
+
+```bash
+npm install @kinotic-ai/persistence
+```
+
+For full documentation, guides, and API reference, visit **[kinotic.ai](https://kinotic.ai)**.

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");