@aerokit/sdk 12.44.0

package/dist/esm/db/decorators.mjs

@@ -0,0 +1,148 @@
+const globalCache = globalThis.__decorator_metadata_cache__ || (globalThis.__decorator_metadata_cache__ = /* @__PURE__ */ new WeakMap());
+function getMetadataArray(constructor) {
+  if (!globalCache.has(constructor)) {
+    globalCache.set(constructor, []);
+  }
+  return globalCache.get(constructor);
+}
+function defer(fn) {
+  Promise.resolve().then(fn);
+}
+function createPropertyDecorator(kind, options) {
+  return function(_, context) {
+    if (context.kind !== "field") {
+      throw new Error(`@${kind} must apply to fields`);
+    }
+    context.addInitializer(function() {
+      const ctor = this.constructor;
+      const propertyName = context.name.toString();
+      const metadataArray = getMetadataArray(ctor);
+      let metadata = metadataArray.find(
+        (m) => m.propertyName === propertyName
+      );
+      if (!metadata) {
+        metadata = {
+          propertyName,
+          isId: false,
+          isGenerated: false
+        };
+        metadataArray.push(metadata);
+      }
+      if (kind === "id") metadata.isId = true;
+      if (kind === "generated") metadata.isGenerated = true;
+      if (kind === "column") metadata.columnOptions = options;
+    });
+  };
+}
+function Documentation(description) {
+  return function(value, context) {
+    if (context.kind === "class") {
+      context.addInitializer(function() {
+        value.$documentation = description;
+      });
+      return value;
+    } else if (context.kind === "field") {
+      context.addInitializer(function() {
+        const ctor = this.constructor;
+        const propertyName = context.name.toString();
+        const metadataArray = getMetadataArray(ctor);
+        let metadata = metadataArray.find(
+          (m) => m.propertyName === propertyName
+        );
+        if (!metadata) {
+          metadata = {
+            propertyName,
+            isId: false,
+            isGenerated: false
+          };
+          metadataArray.push(metadata);
+        }
+        metadata.documentation = description;
+      });
+    }
+  };
+}
+function Entity(entityName) {
+  return function(value, context) {
+    context.addInitializer(function() {
+      defer(() => {
+        const ctor = value;
+        if (ctor.$initialized) return;
+        ctor.$initialized = true;
+        ctor.$entity_name = entityName || ctor.name;
+        const metadataArray = getMetadataArray(ctor);
+        const idMetadata = metadataArray.find((m) => m.isId);
+        if (idMetadata) {
+          ctor.$id_name = idMetadata.propertyName;
+          ctor.$id_column = idMetadata.columnOptions?.name || idMetadata.propertyName.toUpperCase();
+        }
+      });
+    });
+  };
+}
+function Table(tableName) {
+  return function(value, context) {
+    context.addInitializer(function() {
+      value.$table_name = tableName || (context.name?.toString() ?? value.name.toUpperCase());
+    });
+    return value;
+  };
+}
+const Column = (options) => createPropertyDecorator("column", options);
+const Id = () => createPropertyDecorator("id");
+const Generated = (strategy) => createPropertyDecorator("generated");
+function OneToMany(typeFunction, options) {
+  return function(_, context) {
+    if (context.kind !== "field") return;
+    context.addInitializer(function() {
+      const ctor = this.constructor;
+      const propertyName = context.name.toString();
+      const metadataArray = getMetadataArray(ctor);
+      let metadata = metadataArray.find(
+        (m) => m.propertyName === propertyName
+      );
+      if (!metadata) {
+        metadata = {
+          propertyName,
+          isId: false,
+          isGenerated: false
+        };
+        metadataArray.push(metadata);
+      }
+      metadata.oneToManyOptions = { type: typeFunction(), options };
+    });
+  };
+}
+function ManyToOne(typeFunction, options = {}) {
+  return function(_, context) {
+    if (context.kind !== "field") return;
+    context.addInitializer(function() {
+      const ctor = this.constructor;
+      const propertyName = context.name.toString();
+      const metadataArray = getMetadataArray(ctor);
+      let metadata = metadataArray.find(
+        (m) => m.propertyName === propertyName
+      );
+      if (!metadata) {
+        metadata = {
+          propertyName,
+          isId: false,
+          isGenerated: false
+        };
+        metadataArray.push(metadata);
+      }
+      metadata.manyToOneOptions = { type: typeFunction(), options };
+    });
+  };
+}
+export {
+  Column,
+  Documentation,
+  Entity,
+  Generated,
+  Id,
+  ManyToOne,
+  OneToMany,
+  Table
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/db/decorators.ts"],
  "sourcesContent": ["/**\n * * ECMAScript 2025-compliant ORM decorator implementation\n * Compatible with GraalJS runtime.\n * * Features:\n * - Uses context.addInitializer for stable decorator timing\n * - Stores metadata in a global WeakMap cache\n * - Finalizes entity metadata once per class\n * - Defers finalization via microtask (Promise.resolve().then)\n */\n\n// --- Decorator Context Types (based on ECMAScript Decorators proposal) ---\ntype ClassFieldDecoratorContext = {\n  kind: \"field\";\n  name: string | symbol;\n  static: boolean;\n  private: boolean;\n  addInitializer(fn: () => void): void;\n};\n\ntype ClassDecoratorContext = {\n  kind: \"class\";\n  name?: string | symbol;\n  addInitializer(fn: () => void): void;\n};\n\n// --- Metadata Models ---\nexport interface ColumnOptions {\n  name?: string;\n  type?: string;\n  length?: number;\n  nullable?: boolean;\n  defaultValue?: string;\n}\n\nexport interface OneToManyOptions {\n  table?: string;\n  joinColumn: string;\n  cascade?: \"all\" | \"none\" | \"persist\" | \"merge\" | \"remove\";\n  inverse?: boolean;\n  lazy?: boolean;\n  fetch?: \"select\" | \"join\";\n  joinColumnNotNull?: boolean;\n}\n\nexport interface ManyToOneOptions {\n  joinColumn?: string;\n  cascade?: \"all\" | \"none\" | \"persist\" | \"merge\" | \"remove\";\n  nullable?: boolean;\n  lazy?: boolean;\n  fetch?: \"select\" | \"join\";\n}\n\ninterface PropertyMetadata {\n  propertyName: string;\n  isId: boolean;\n  isGenerated: boolean;\n  documentation?: string;\n  columnOptions?: ColumnOptions;\n  oneToManyOptions?: { type: Function; options: OneToManyOptions };\n  manyToOneOptions?: { type: Function; options: ManyToOneOptions };\n}\n\nexport interface EntityConstructor extends Function {\n  new (...args: any[]): any;\n  $entity_name: string;\n  $table_name: string;\n  $id_name: string;\n  $id_column: string;\n  $initialized?: boolean;\n  $documentation?: string;\n}\n\n// --- Global Metadata Cache ---\nconst globalCache: WeakMap<Function, PropertyMetadata[]> =\n  (globalThis as any).__decorator_metadata_cache__ ||\n  ((globalThis as any).__decorator_metadata_cache__ = new WeakMap());\n\nfunction getMetadataArray(constructor: Function): PropertyMetadata[] {\n  if (!globalCache.has(constructor)) {\n    globalCache.set(constructor, []);\n  }\n  return globalCache.get(constructor)!;\n}\n\n// --- Defer Helper (GraalJS-safe microtask) ---\nfunction defer(fn: () => void): void {\n  // Uses Promise microtask queue for deferred execution\n  Promise.resolve().then(fn);\n}\n\n// --- Core Property Decorator Factory ---\nfunction createPropertyDecorator(\n  kind: \"column\" | \"id\" | \"generated\",\n  options?: ColumnOptions\n) {\n  return function (_: any, context: ClassFieldDecoratorContext) {\n    if (context.kind !== \"field\") {\n      throw new Error(`@${kind} must apply to fields`);\n    }\n\n    context.addInitializer(function () {\n      const ctor = (this as any).constructor as EntityConstructor;\n      const propertyName = context.name.toString();\n      const metadataArray = getMetadataArray(ctor);\n\n      let metadata = metadataArray.find(\n        (m) => m.propertyName === propertyName\n      );\n\n      if (!metadata) {\n        metadata = {\n          propertyName: propertyName,\n          isId: false,\n          isGenerated: false,\n        };\n        metadataArray.push(metadata);\n      }\n\n      if (kind === \"id\") metadata.isId = true;\n      if (kind === \"generated\") metadata.isGenerated = true;\n      if (kind === \"column\") metadata.columnOptions = options;\n    });\n  };\n}\n\n// --- @Documentation Decorator (Dual-Purpose) ---\n/**\n * Adds documentation metadata to a class or a field.\n */\nexport function Documentation(description: string) {\n  return function (\n    value: Function | any,\n    context: ClassDecoratorContext | ClassFieldDecoratorContext\n  ) {\n    if (context.kind === \"class\") {\n      context.addInitializer(function () {\n        (value as EntityConstructor).$documentation = description;\n      });\n      return value;\n    } else if (context.kind === \"field\") {\n      context.addInitializer(function () {\n        const ctor = (this as any).constructor as EntityConstructor;\n        const propertyName = context.name.toString();\n        const metadataArray = getMetadataArray(ctor);\n\n        let metadata = metadataArray.find(\n          (m) => m.propertyName === propertyName\n        );\n\n        if (!metadata) {\n          metadata = {\n            propertyName: propertyName,\n            isId: false,\n            isGenerated: false,\n          };\n          metadataArray.push(metadata);\n        }\n\n        metadata.documentation = description;\n      });\n    }\n  };\n}\n\n\n// --- @Entity Decorator ---\n/**\n * Marks a class as an entity and initiates metadata finalization.\n * @param entityName The name of the entity (defaults to class name).\n */\nexport function Entity(entityName?: string) {\n  return function (value: Function, context: ClassDecoratorContext) {\n    context.addInitializer(function () {\n      // Defer execution to ensure all field decorators have run\n      defer(() => {\n        const ctor = value as EntityConstructor;\n\n        // Prevent duplicate registration (idempotency)\n        if (ctor.$initialized) return;\n        ctor.$initialized = true;\n\n        ctor.$entity_name = entityName || ctor.name;\n\n        const metadataArray = getMetadataArray(ctor);\n        const idMetadata = metadataArray.find((m) => m.isId);\n\n        if (idMetadata) {\n          ctor.$id_name = idMetadata.propertyName;\n          // Determine ID column name: use explicit name or convert property name to upper case\n          ctor.$id_column =\n            idMetadata.columnOptions?.name ||\n            idMetadata.propertyName.toUpperCase();\n        }\n\n        // Future: Logic to map all properties to columns/relations goes here\n      });\n    });\n  };\n}\n\n// --- @Table Decorator ---\n/**\n * Specifies the database table name for the entity.\n * @param tableName The table name (defaults to uppercase class name).\n */\nexport function Table(tableName?: string) {\n  return function <T extends EntityConstructor>(\n    value: T,\n    context: ClassDecoratorContext\n  ) {\n    context.addInitializer(function () {\n      (value as EntityConstructor).$table_name =\n        tableName || (context.name?.toString() ?? value.name.toUpperCase());\n    });\n\n    return value;\n  };\n}\n\n// --- Exported Property Decorators ---\n/**\n * Marks a property as a standard database column.\n */\nexport const Column = (options?: ColumnOptions) =>\n  createPropertyDecorator(\"column\", options);\n\n/**\n * Marks a property as the entity's primary key.\n */\nexport const Id = () => createPropertyDecorator(\"id\");\n\n/**\n * Marks a property as a generated value (e.g., auto-increment).\n * @param strategy The generation strategy (e.g., \"IDENTITY\"). Parameter is currently unused in logic.\n */\nexport const Generated = (strategy: string) =>\n  createPropertyDecorator(\"generated\");\n\n/**\n * Defines a one-to-many relationship.\n */\nexport function OneToMany(\n  typeFunction: () => Function,\n  options: OneToManyOptions\n) {\n  return function (_: any, context: ClassFieldDecoratorContext) {\n    if (context.kind !== \"field\") return;\n\n    context.addInitializer(function () {\n      const ctor = (this as any).constructor as EntityConstructor;\n      const propertyName = context.name.toString();\n      const metadataArray = getMetadataArray(ctor);\n\n      let metadata = metadataArray.find(\n        (m) => m.propertyName === propertyName\n      );\n\n      if (!metadata) {\n        metadata = {\n          propertyName: propertyName,\n          isId: false,\n          isGenerated: false,\n        };\n        metadataArray.push(metadata);\n      }\n\n      metadata.oneToManyOptions = { type: typeFunction(), options };\n    });\n  };\n}\n\n/**\n * Defines a many-to-one relationship.\n */\nexport function ManyToOne(\n  typeFunction: () => Function,\n  options: ManyToOneOptions = {}\n) {\n  return function (_: any, context: ClassFieldDecoratorContext) {\n    if (context.kind !== \"field\") return;\n\n    context.addInitializer(function () {\n      const ctor = (this as any).constructor as EntityConstructor;\n      const propertyName = context.name.toString();\n      const metadataArray = getMetadataArray(ctor);\n\n      let metadata = metadataArray.find(\n        (m) => m.propertyName === propertyName\n      );\n\n      if (!metadata) {\n        metadata = {\n          propertyName: propertyName,\n          isId: false,\n          isGenerated: false,\n        };\n        metadataArray.push(metadata);\n      }\n\n      metadata.manyToOneOptions = { type: typeFunction(), options };\n    });\n  };\n}"],
  "mappings": "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",
  "names": []
}


package/dist/esm/db/index.mjs

@@ -0,0 +1,42 @@
+import * as dao from "./dao";
+export * from "./database";
+import { Database } from "./database";
+import * as orm from "./orm";
+import * as ormstatements from "./ormstatements";
+export * from "./sql";
+import { SQLBuilder } from "./sql";
+export * from "./procedure";
+import { Procedure } from "./procedure";
+export * from "./sequence";
+import { Sequence } from "./sequence";
+export * from "./query";
+import { Query } from "./query";
+export * from "./update";
+import { Update } from "./update";
+export * from "./insert";
+import { Insert } from "./insert";
+export * from "./store";
+import { Store } from "./store";
+export * from "./repository";
+import { Repository } from "./repository";
+export * from "./decorators";
+import * as decorators from "./decorators";
+export * from "./translator";
+import { Translator } from "./translator";
+export {
+  dao,
+  Database as database,
+  decorators,
+  Insert as insert,
+  orm,
+  ormstatements,
+  Procedure as procedure,
+  Query as query,
+  Repository as repository,
+  Sequence as sequence,
+  SQLBuilder as sql,
+  Store as store,
+  Translator as translator,
+  Update as update
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2RiL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJleHBvcnQgKiBhcyBkYW8gZnJvbSBcIi4vZGFvXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kYXRhYmFzZVwiO1xuZXhwb3J0IHsgRGF0YWJhc2UgYXMgZGF0YWJhc2UgfSBmcm9tIFwiLi9kYXRhYmFzZVwiO1xuZXhwb3J0ICogYXMgb3JtIGZyb20gXCIuL29ybVwiO1xuZXhwb3J0ICogYXMgb3Jtc3RhdGVtZW50cyBmcm9tIFwiLi9vcm1zdGF0ZW1lbnRzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zcWxcIjtcbmV4cG9ydCB7IFNRTEJ1aWxkZXIgYXMgc3FsIH0gZnJvbSBcIi4vc3FsXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9wcm9jZWR1cmVcIjtcbmV4cG9ydCB7IFByb2NlZHVyZSBhcyBwcm9jZWR1cmUgfSBmcm9tIFwiLi9wcm9jZWR1cmVcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3NlcXVlbmNlXCI7XG5leHBvcnQgeyBTZXF1ZW5jZSBhcyBzZXF1ZW5jZSB9IGZyb20gXCIuL3NlcXVlbmNlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9xdWVyeVwiO1xuZXhwb3J0IHsgUXVlcnkgYXMgcXVlcnkgfSBmcm9tIFwiLi9xdWVyeVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vdXBkYXRlXCI7XG5leHBvcnQgeyBVcGRhdGUgYXMgdXBkYXRlIH0gZnJvbSBcIi4vdXBkYXRlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9pbnNlcnRcIjtcbmV4cG9ydCB7IEluc2VydCBhcyBpbnNlcnQgfSBmcm9tIFwiLi9pbnNlcnRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3N0b3JlXCI7XG5leHBvcnQgeyBTdG9yZSBhcyBzdG9yZSB9IGZyb20gXCIuL3N0b3JlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9yZXBvc2l0b3J5XCI7XG5leHBvcnQgeyBSZXBvc2l0b3J5IGFzIHJlcG9zaXRvcnkgfSBmcm9tIFwiLi9yZXBvc2l0b3J5XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kZWNvcmF0b3JzXCI7XG5leHBvcnQgKiBhcyBkZWNvcmF0b3JzIGZyb20gXCIuL2RlY29yYXRvcnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3RyYW5zbGF0b3JcIjtcbmV4cG9ydCB7IFRyYW5zbGF0b3IgYXMgdHJhbnNsYXRvciB9IGZyb20gXCIuL3RyYW5zbGF0b3JcIjsiXSwKICAibWFwcGluZ3MiOiAiQUFBQSxZQUFZLFNBQVM7QUFDckIsY0FBYztBQUNkLFNBQXFCLGdCQUFnQjtBQUNyQyxZQUFZLFNBQVM7QUFDckIsWUFBWSxtQkFBbUI7QUFDL0IsY0FBYztBQUNkLFNBQXVCLGtCQUFXO0FBQ2xDLGNBQWM7QUFDZCxTQUFzQixpQkFBaUI7QUFDdkMsY0FBYztBQUNkLFNBQXFCLGdCQUFnQjtBQUNyQyxjQUFjO0FBQ2QsU0FBa0IsYUFBYTtBQUMvQixjQUFjO0FBQ2QsU0FBbUIsY0FBYztBQUNqQyxjQUFjO0FBQ2QsU0FBbUIsY0FBYztBQUNqQyxjQUFjO0FBQ2QsU0FBa0IsYUFBYTtBQUMvQixjQUFjO0FBQ2QsU0FBdUIsa0JBQWtCO0FBQ3pDLGNBQWM7QUFDZCxZQUFZLGdCQUFnQjtBQUM1QixjQUFjO0FBQ2QsU0FBdUIsa0JBQWtCOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/esm/db/insert.mjs

@@ -0,0 +1,32 @@
+const DatabaseFacade = Java.type("org.eclipse.dirigible.components.api.db.DatabaseFacade");
+class Insert {
+  /**
+   * Executes a single parameterized INSERT statement.
+   * * @param sql The SQL query to execute, with '?' placeholders for parameters.
+   * @param parameters An optional array of values to replace the '?' placeholders.
+   * @param datasourceName The name of the database connection to use (optional).
+   * @returns An array of records representing the result of the insertion (e.g., generated keys).
+   */
+  static execute(sql, parameters, datasourceName) {
+    const params = parameters ? JSON.stringify(parameters) : void 0;
+    return DatabaseFacade.insert(sql, params, datasourceName);
+  }
+  /**
+   * Executes multiple parameterized INSERT statements as a batch operation.
+   * * @param sql The SQL query to execute, with '?' placeholders for parameters.
+   * @param parameters An optional array of parameter arrays, where each inner array corresponds to one execution of the SQL statement.
+   * @param datasourceName The name of the database connection to use (optional).
+   * @returns An array of records representing the results of the batched insertions.
+   */
+  static executeMany(sql, parameters, datasourceName) {
+    const params = parameters ? JSON.stringify(parameters) : void 0;
+    return DatabaseFacade.insertMany(sql, params, datasourceName);
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Insert;
+}
+export {
+  Insert
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/db/orm.mjs

@@ -0,0 +1,225 @@
+function ORM(orm) {
+  this.orm = orm;
+  for (var i in orm) {
+    this[i] = orm[i];
+  }
+}
+;
+ORM.prototype.ASSOCIATION_TYPES = Object.freeze({
+  "ONE-TO-ONE": "one-to-one",
+  "ONE-TO-MANY": "one-to-many",
+  "MANY-TO-MANY": "many-to-many",
+  "MANY-TO-ONE": "many-to-one"
+});
+ORM.prototype.ASSOCIATION_TYPES_VALUES = Object.keys(ORM.prototype.ASSOCIATION_TYPES).map(function(key) {
+  return ORM.prototype.ASSOCIATION_TYPES[key];
+});
+ORM.prototype.getPrimaryKey = function() {
+  if (!this.idProperty) {
+    if (!this.properties || !this.properties.length)
+      throw new Error("Invalid orm configuration - no properties are defined");
+    const id = this.properties.filter(function(property) {
+      return property.id;
+    });
+    if (!id.length)
+      throw new Error("Invalid orm configuration - no id property is defined");
+    this.idProperty = id[0];
+  }
+  return this.idProperty;
+};
+ORM.prototype.isAutoIncrementPrimaryKey = function() {
+  if (!this.autoIncrementPrimaryKeyProperty) {
+    if (!this.properties || !this.properties.length)
+      throw new Error("Invalid orm configuration - no properties are defined");
+    let isAutoIncrementOldVersion = false;
+    const autoIncrementPrimaryKeyProperty = this.properties.filter(function(property) {
+      if (property.id && (property.autoIncrement === void 0 || property.autoIncrement === null)) {
+        isAutoIncrementOldVersion = true;
+      }
+      return property.id && (property.autoIncrement || isAutoIncrementOldVersion);
+    });
+    this.autoIncrementPrimaryKeyProperty = autoIncrementPrimaryKeyProperty.length > 0;
+  }
+  return this.autoIncrementPrimaryKeyProperty;
+};
+ORM.prototype.getProperty = function(name) {
+  if (name === void 0)
+    throw new Error("Illegal argument: name[" + name + "]");
+  if (!this.properties || !this.properties.length)
+    throw new Error("Invalid orm configuration - no properties are defined");
+  const property = this.properties.filter(function(property2) {
+    return property2.name === name;
+  });
+  return property.length > 0 ? property[0] : void 0;
+};
+ORM.prototype.getMandatoryProperties = function() {
+  if (!this.mandatoryProperties) {
+    if (!this.properties || !this.properties.length)
+      throw new Error("Invalid orm configuration - no properties are defined");
+    const mandatories = this.properties.filter(function(property) {
+      return property.required;
+    });
+    this.mandatoryProperties = mandatories;
+  }
+  return this.mandatoryProperties;
+};
+ORM.prototype.getOptionalProperties = function() {
+  if (!this.optionalProperties) {
+    if (!this.properties || !this.properties.length)
+      throw new Error("Invalid orm configuration - no properties are defined");
+    const mandatories = this.properties.filter(function(property) {
+      return !property.required;
+    });
+    this.optionalProperties = mandatories;
+  }
+  return this.optionalProperties;
+};
+ORM.prototype.getUniqueProperties = function() {
+  if (!this.uniqueProperties) {
+    if (!this.properties || !this.properties.length)
+      throw new Error("Invalid orm configuration - no properties are defined");
+    const uniques = this.properties.filter(function(property) {
+      return property.unique;
+    });
+    this.uniqueProperties = uniques;
+  }
+  return this.uniqueProperties;
+};
+ORM.prototype.associationKeys = function() {
+  let keys = [];
+  if (this.associations) {
+    keys = this.associations.map(function(assoc) {
+      return assoc.joinKey;
+    });
+  }
+  return keys;
+};
+ORM.prototype.getAssociationNames = function() {
+  let names = [];
+  if (this.associations) {
+    names = this.associations.map(function(assoc) {
+      return assoc.name;
+    });
+  }
+  return names;
+};
+ORM.prototype.getAssociation = function(associationName) {
+  if (this.associations) {
+    return this.associations.filter(function(assoc) {
+      return assoc.name === associationName;
+    })[0];
+  }
+  return;
+};
+ORM.prototype.validate = function() {
+  let i;
+  if (!this.table)
+    throw new Error("Illegal configuration: invalid property table[" + this.table + "]");
+  if (!this.properties)
+    throw new Error("Illegal configuration: invalid property properties[" + this.properties + "]");
+  if (this.properties.constructor !== Array)
+    throw new Error("Illegal configuration: property 'properties' type is expected ot be Array. Instead, it was " + typeof this.properties);
+  if (!this.getPrimaryKey())
+    throw new Error("Illegal configuration: No primary key specifed");
+  for (i = 0; i < this.properties.length; i++) {
+    const property = this.properties[i];
+    if (!property.name)
+      throw new Error("Illegal configuration: invalid property name[" + property.name + "]");
+    if (!property.type)
+      throw new Error("Illegal configuration: invalid property type[" + property.type + "]");
+    if (!property.column)
+      throw new Error("Illegal configuration: invalid property column[" + property.column + "]");
+    if (property.allowedOps) {
+      if (property.allowedOps.constructor !== Array)
+        throw new Error("Illegal configuration: property[" + property.name + "]  allowedOps is expected ot be Array. Instead, it was " + typeof property.allowedOps);
+      for (let j = 0; j < property.allowedOps.length; j++) {
+        if (["insert", "update"].indexOf(property.allowedOps[j]) < 0)
+          throw new Error("Illegal configuration: property[" + property.name + "] allowedOps[" + property.allowedOps + "] must be an array containing some or all of the following values: ['insert','update']");
+      }
+    }
+  }
+  if (this.associations) {
+    if (this.associations.constructor !== Array)
+      throw new Error("Illegal configuration: property 'associations' type is expected ot be Array. Instead, it was " + typeof this.associations);
+    for (i = 0; i < this.associations.length; i++) {
+      const association = this.associations[i];
+      if (!association.name)
+        throw new Error("Illegal configuration: Association property name[" + association.name + "]");
+      if (ORM.prototype.ASSOCIATION_TYPES_VALUES.indexOf(association.type) < 0)
+        throw new Error("Illegal configuration: Association " + association.name + " property type[" + association.type + "] must be one of " + ORM.prototype.ASSOCIATION_TYPES_VALUES);
+      if (!association.joinKey && "many-to-one" !== association.type)
+        throw new Error("Illegal configuration: invalid association joinKey[" + association.joinKey + "]");
+      if (association.targetDao && association.targetDao.constructor !== Function)
+        throw new Error("Invalid configuration: Association " + association.name + " targetDao property is expected to be function. Instead, it is: " + typeof association.targetDao);
+      if (association.type === ORM.prototype.ASSOCIATION_TYPES["MANY-TO-MANY"]) {
+        if (!association.joinDao)
+          throw new Error("Illegal configuration: Association " + association.name + " joinDao[" + association.joinDao + "] value");
+        if (association.joinDao && association.joinDao.constructor !== Function)
+          throw new Error("Invalid configuration: Association " + association.name + " joinDao property is expected to be function. Instead, it is: " + typeof association.joinDao);
+      }
+    }
+  }
+};
+ORM.prototype.toColumn = function(ormProperty) {
+  let column;
+  if (ormProperty) {
+    column = {
+      name: '"' + ormProperty.column + '"',
+      type: ormProperty.type,
+      length: String(ormProperty.length),
+      primaryKey: String(ormProperty.id === void 0 ? false : ormProperty.id),
+      nullable: String(!ormProperty.required),
+      defaultValue: ormProperty.defaultValue
+    };
+  }
+  return column;
+};
+ORM.prototype.toTable = function() {
+  let table = {
+    name: this.table,
+    type: "TABLE",
+    columns: null,
+    constraints: null
+  };
+  const uniqueIndices = [];
+  const primaryKeys = [];
+  if (this.properties) {
+    table.columns = [];
+    this.properties.forEach(function(property) {
+      var column = this.toColumn(property);
+      if (property.unique)
+        uniqueIndices.push({
+          "columns": column.name
+        });
+      if (property.id)
+        primaryKeys.push({
+          "columns": column.name
+        });
+      table.columns.push(column);
+    });
+  }
+  if (primaryKeys.length > 1 || uniqueIndices.length > 0) {
+    table["constraints"] = {};
+  }
+  if (primaryKeys.length > 1) {
+    table.columns = table.columns.map(function(column) {
+      column.primaryKey = "false";
+      return column;
+    });
+    table.constraints["primarKeys"] = primaryKeys;
+  }
+  if (uniqueIndices.length > 0)
+    table.constraints["uniqueIndices"] = uniqueIndices;
+  return table;
+};
+function get(orm) {
+  const _orm = new ORM(orm);
+  _orm.validate();
+  return _orm;
+}
+;
+export {
+  ORM,
+  get
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/db/orm.ts"],
  "sourcesContent": ["\"use strict\";\n\n/**\n * Supported ORM schema:\n * ```\n * {\n *\t name: <string>,\n *   table: <string>,\n *   properties: [{\n *\t   name: <string>,\n *\t   column: <string>,\n *\t   id: <boolean>,\n *\t   required: <boolean>,\n *\t   unique: <boolean>,\n *\t   dbValue: <function>,\n *\t   value: <function>,\n *\t   allowedOps: <Array['insert','update']>\n *   }],\n * \t associations: [{\n *\t   name: <string>,\n *     joinKey: <string>,\n *     key: <string>,\n *     type: <ORM.ASSOCIATION_TYPES>,\n *     targetDao: <function|DAO>,\n *     joinDao: <function|DAO>,\n *     defaults: <Object>,\n *   }]\n * }\n * ```\n *\n */\n\nexport interface ORMDefinition {\n    table: string,\n    properties: {\n        name: string,\n        column: string,\n        type: string,\n        id?: boolean,\n        required?: boolean,\n        unique?: boolean,\n        autoIncrement?: boolean,\n        allowedOps?: ('insert' | 'update')[]\n    }[]\n}\n\nexport function ORM(orm: ORMDefinition) {\n\tthis.orm = orm;\n\tfor (var i in orm) {\n\t\tthis[i] = orm[i];\n\t}\n};\n\nORM.prototype.ASSOCIATION_TYPES = Object.freeze({\n\t\"ONE-TO-ONE\": \"one-to-one\",\n\t\"ONE-TO-MANY\": \"one-to-many\",\n\t\"MANY-TO-MANY\": \"many-to-many\",\n\t\"MANY-TO-ONE\": \"many-to-one\"\n});\nORM.prototype.ASSOCIATION_TYPES_VALUES = Object.keys(ORM.prototype.ASSOCIATION_TYPES)\n\t.map(function (key) {\n\t\treturn ORM.prototype.ASSOCIATION_TYPES[key];\n\t});\n\nORM.prototype.getPrimaryKey = function () {\n\tif (!this.idProperty) {\n\t\tif (!this.properties || !this.properties.length)\n\t\t\tthrow new Error('Invalid orm configuration - no properties are defined');\n\t\tconst id = this.properties.filter(function (property) {\n\t\t\treturn property.id;\n\t\t});\n\t\tif (!id.length)\n\t\t\tthrow new Error('Invalid orm configuration - no id property is defined');\n\t\tthis.idProperty = id[0];\n\t}\n\treturn this.idProperty;\n};\n\nORM.prototype.isAutoIncrementPrimaryKey = function () {\n\tif (!this.autoIncrementPrimaryKeyProperty) {\n\t\tif (!this.properties || !this.properties.length)\n\t\t\tthrow new Error('Invalid orm configuration - no properties are defined');\n\t\tlet isAutoIncrementOldVersion = false;\n\t\tconst autoIncrementPrimaryKeyProperty = this.properties.filter(function (property) {\n\t\t\tif (property.id && (property.autoIncrement === undefined || property.autoIncrement === null)) {\n\t\t\t\tisAutoIncrementOldVersion = true;\n\t\t\t}\n\t\t\treturn property.id && (property.autoIncrement || isAutoIncrementOldVersion);\n\t\t});\n\t\tthis.autoIncrementPrimaryKeyProperty = autoIncrementPrimaryKeyProperty.length > 0;\n\t}\n\treturn this.autoIncrementPrimaryKeyProperty;\n};\n\nORM.prototype.getProperty = function (name) {\n\tif (name === undefined)\n\t\tthrow new Error('Illegal argument: name[' + name + ']');\n\tif (!this.properties || !this.properties.length)\n\t\tthrow new Error('Invalid orm configuration - no properties are defined');\n\tconst property = this.properties.filter(function (property) {\n\t\treturn property.name === name;\n\t});\n\treturn property.length > 0 ? property[0] : undefined;\n};\n\nORM.prototype.getMandatoryProperties = function () {\n\tif (!this.mandatoryProperties) {\n\t\tif (!this.properties || !this.properties.length)\n\t\t\tthrow new Error('Invalid orm configuration - no properties are defined');\n\t\tconst mandatories = this.properties.filter(function (property) {\n\t\t\treturn property.required;\n\t\t});\n\t\tthis.mandatoryProperties = mandatories;\n\t}\n\treturn this.mandatoryProperties;\n};\n\nORM.prototype.getOptionalProperties = function () {\n\tif (!this.optionalProperties) {\n\t\tif (!this.properties || !this.properties.length)\n\t\t\tthrow new Error('Invalid orm configuration - no properties are defined');\n\t\tconst mandatories = this.properties.filter(function (property) {\n\t\t\treturn !property.required;\n\t\t});\n\t\tthis.optionalProperties = mandatories;\n\t}\n\treturn this.optionalProperties;\n};\n\nORM.prototype.getUniqueProperties = function () {\n\tif (!this.uniqueProperties) {\n\t\tif (!this.properties || !this.properties.length)\n\t\t\tthrow new Error('Invalid orm configuration - no properties are defined');\n\t\tconst uniques = this.properties.filter(function (property) {\n\t\t\treturn property.unique;\n\t\t});\n\t\tthis.uniqueProperties = uniques;\n\t}\n\treturn this.uniqueProperties;\n};\n\n//TODO: remove this or improve by key type.\nORM.prototype.associationKeys = function () {\n\tlet keys = [];\n\tif (this.associations) {\n\t\tkeys = this.associations.map(function (assoc) {\n\t\t\treturn assoc.joinKey;\n\t\t});\n\t}\n\treturn keys;\n};\n\nORM.prototype.getAssociationNames = function () {\n\tlet names = [];\n\tif (this.associations) {\n\t\tnames = this.associations.map(function (assoc) {\n\t\t\treturn assoc.name;\n\t\t});\n\t}\n\treturn names;\n};\n\nORM.prototype.getAssociation = function (associationName) {\n\tif (this.associations) {\n\t\treturn this.associations\n\t\t\t.filter(function (assoc) {\n\t\t\t\treturn assoc.name === associationName;\n\t\t\t})[0];\n\t}\n\treturn;\n};\n\nORM.prototype.validate = function () {\n\tlet i;\n\tif (!this.table)\n\t\tthrow new Error('Illegal configuration: invalid property table[' + this.table + ']');\n\tif (!this.properties)\n\t\tthrow new Error('Illegal configuration: invalid property properties[' + this.properties + ']');\n\tif (this.properties.constructor !== Array)\n\t\tthrow new Error(\"Illegal configuration: property 'properties' type is expected ot be Array. Instead, it was \" + (typeof this.properties));\n\tif (!this.getPrimaryKey())\n\t\tthrow new Error('Illegal configuration: No primary key specifed');\n\tfor (i = 0; i < this.properties.length; i++) {\n\t\tconst property = this.properties[i];\n\t\tif (!property.name)\n\t\t\tthrow new Error('Illegal configuration: invalid property name[' + property.name + ']');\n\t\tif (!property.type)\n\t\t\tthrow new Error('Illegal configuration: invalid property type[' + property.type + ']');\n\t\tif (!property.column)\n\t\t\tthrow new Error('Illegal configuration: invalid property column[' + property.column + ']');\n\t\tif (property.allowedOps) {\n\t\t\tif (property.allowedOps.constructor !== Array)\n\t\t\t\tthrow new Error(\"Illegal configuration: property[\" + property.name + \"]  allowedOps is expected ot be Array. Instead, it was \" + (typeof property.allowedOps));\n\t\t\tfor (let j = 0; j < property.allowedOps.length; j++) {\n\t\t\t\tif (['insert', 'update'].indexOf(property.allowedOps[j]) < 0)\n\t\t\t\t\tthrow new Error(\"Illegal configuration: property[\" + property.name + \"] allowedOps[\" + property.allowedOps + \"] must be an array containing some or all of the following values: ['insert','update']\");\n\t\t\t}\n\t\t}\n\t}\n\tif (this.associations) {\n\t\tif (this.associations.constructor !== Array)\n\t\t\tthrow new Error(\"Illegal configuration: property 'associations' type is expected ot be Array. Instead, it was \" + (typeof this.associations));\n\t\tfor (i = 0; i < this.associations.length; i++) {\n\t\t\tconst association = this.associations[i];\n\t\t\tif (!association.name)\n\t\t\t\tthrow new Error(\"Illegal configuration: Association property name[\" + association.name + \"]\");\n\t\t\tif (ORM.prototype.ASSOCIATION_TYPES_VALUES.indexOf(association.type) < 0)\n\t\t\t\tthrow new Error(\"Illegal configuration: Association \" + association.name + \" property type[\" + association.type + \"] must be one of \" + ORM.prototype.ASSOCIATION_TYPES_VALUES);\n\t\t\tif (!association.joinKey && 'many-to-one' !== association.type)\n\t\t\t\tthrow new Error('Illegal configuration: invalid association joinKey[' + association.joinKey + ']');\n\t\t\tif (association.targetDao && association.targetDao.constructor !== Function)\n\t\t\t\tthrow new Error('Invalid configuration: Association ' + association.name + ' targetDao property is expected to be function. Instead, it is: ' + (typeof association.targetDao));\n\t\t\tif (association.type === ORM.prototype.ASSOCIATION_TYPES['MANY-TO-MANY']) {\n\t\t\t\tif (!association.joinDao)\n\t\t\t\t\tthrow new Error('Illegal configuration: Association ' + association.name + ' joinDao[' + association.joinDao + '] value');\n\t\t\t\tif (association.joinDao && association.joinDao.constructor !== Function)\n\t\t\t\t\tthrow new Error('Invalid configuration: Association ' + association.name + ' joinDao property is expected to be function. Instead, it is: ' + (typeof association.joinDao));\n\t\t\t}\n\t\t}\n\t}\n};\n\nORM.prototype.toColumn = function (ormProperty) {\n\tlet column;\n\tif (ormProperty) {\n\t\tcolumn = {\n\t\t\tname: \"\\\"\" + ormProperty.column + \"\\\"\",\n\t\t\ttype: ormProperty.type,\n\t\t\tlength: String(ormProperty.length),\n\t\t\tprimaryKey: String(ormProperty.id === undefined ? false : ormProperty.id),\n\t\t\tnullable: String(!ormProperty.required),\n\t\t\tdefaultValue: ormProperty.defaultValue\n\t\t};\n\t}\n\treturn column;\n};\n\nORM.prototype.toTable = function () {\n\tlet table = {\n\t\tname: this.table,\n\t\ttype: \"TABLE\",\n\t\tcolumns: null,\n\t\tconstraints: null,\n\t};\n\n\tconst uniqueIndices = [];\n\tconst primaryKeys = [];\n\tif (this.properties) {\n\t\ttable.columns = [];\n\t\tthis.properties.forEach(function (property) {\n\t\t\tvar column = this.toColumn(property);\n\t\t\tif (property.unique)\n\t\t\t\tuniqueIndices.push({\n\t\t\t\t\t\"columns\": column.name\n\t\t\t\t});\n\t\t\tif (property.id)\n\t\t\t\tprimaryKeys.push({\n\t\t\t\t\t\"columns\": column.name\n\t\t\t\t});\n\t\t\t//TODO : analyze associations to add FKs if possible\n\t\t\ttable.columns.push(column);\n\t\t});\n\t}\n\n\tif (primaryKeys.length > 1 || uniqueIndices.length > 0) {\n\t\ttable[\"constraints\"] = {};\n\t}\n\n\tif (primaryKeys.length > 1) {\n\t\ttable.columns = table.columns.map(function (column) {\n\t\t\tcolumn.primaryKey = \"false\";\n\t\t\treturn column;\n\t\t});\n\t\ttable.constraints[\"primarKeys\"] = primaryKeys;\n\t}\n\tif (uniqueIndices.length > 0)\n\t\ttable.constraints[\"uniqueIndices\"] = uniqueIndices;\n\n\treturn table;\n};\n\nexport function get(orm: ORMDefinition) {\n\tconst _orm = new ORM(orm);\n\t_orm.validate();\n\treturn _orm;\n};\n"],
  "mappings": "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",
  "names": ["property"]
}
