@aerokit/sdk 12.44.0

package/dist/cjs/db/sequence.js

@@ -0,0 +1,59 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sequence_exports = {};
+__export(sequence_exports, {
+  Sequence: () => Sequence
+});
+module.exports = __toCommonJS(sequence_exports);
+const DatabaseFacade = Java.type("org.eclipse.dirigible.components.api.db.DatabaseFacade");
+class Sequence {
+  /**
+   * Retrieves the next available value from a specified sequence.
+   *
+   * @param sequence The name of the database sequence.
+   * @param tableName Optional: The name of the table associated with the sequence (depends on database dialect/facade implementation).
+   * @param datasourceName Optional: The name of the database connection to use.
+   * @returns The next sequence value as a number.
+   */
+  static nextval(sequence, tableName, datasourceName) {
+    return DatabaseFacade.nextval(sequence, datasourceName, tableName);
+  }
+  /**
+   * Creates a new database sequence.
+   *
+   * @param sequence The name of the sequence to create.
+   * @param start Optional: The starting value for the sequence (defaults to 1 if not provided).
+   * @param datasourceName Optional: The name of the database connection to use.
+   */
+  static create(sequence, start, datasourceName) {
+    DatabaseFacade.createSequence(sequence, start, datasourceName);
+  }
+  /**
+   * Drops (deletes) an existing database sequence.
+   *
+   * @param sequence The name of the sequence to drop.
+   * @param datasourceName Optional: The name of the database connection to use.
+   */
+  static drop(sequence, datasourceName) {
+    DatabaseFacade.dropSequence(sequence, datasourceName);
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Sequence;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/db/sql.js

@@ -0,0 +1,516 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sql_exports = {};
+__export(sql_exports, {
+  CreateBuilder: () => CreateBuilder,
+  CreateSequenceBuilder: () => CreateSequenceBuilder,
+  CreateTableBuilder: () => CreateTableBuilder,
+  CreateViewBuilder: () => CreateViewBuilder,
+  DeleteBuilder: () => DeleteBuilder,
+  DropBuilder: () => DropBuilder,
+  DropSequenceBuilder: () => DropSequenceBuilder,
+  DropTableBuilder: () => DropTableBuilder,
+  DropViewBuilder: () => DropViewBuilder,
+  InsertBuilder: () => InsertBuilder,
+  NextvalBuilder: () => NextvalBuilder,
+  SQLBuilder: () => SQLBuilder,
+  SelectBuilder: () => SelectBuilder,
+  UpdateBuilder: () => UpdateBuilder
+});
+module.exports = __toCommonJS(sql_exports);
+const DatabaseFacade = Java.type("org.eclipse.dirigible.components.api.db.DatabaseFacade");
+const DataTypeEnum = Java.type("org.eclipse.dirigible.database.sql.DataType");
+class AbstractSQLBuilder {
+  // The underlying Java SQL Builder object
+  constructor(connection) {
+    this.params = [];
+    this.connection = connection;
+    this.native = connection ? DatabaseFacade.getNative(connection.native) : DatabaseFacade.getDefault();
+    this.native = this.prepareBuilder(this.native);
+  }
+  /**
+   * Hook for subclasses to set up the native builder object (e.g., calling .select()).
+   */
+  prepareBuilder(builder) {
+    return builder;
+  }
+  parameters() {
+    return this.params;
+  }
+  /**
+   * Adds parameter(s) to the internal list. Handles single values and arrays of values.
+   */
+  addParameter(value) {
+    if (value === void 0 || value === null) {
+      return;
+    }
+    if (Array.isArray(value)) {
+      this.params.push(...value);
+    } else {
+      this.params.push(value);
+    }
+  }
+  /**
+   * Builds and returns the final SQL string.
+   */
+  build() {
+    return this.native.build();
+  }
+}
+class SQLBuilder extends AbstractSQLBuilder {
+  /**
+   * Factory method to get a dialect-specific SQLBuilder instance.
+   */
+  static getDialect(connection) {
+    return new SQLBuilder(connection);
+  }
+  select() {
+    return new SelectBuilder(this.connection);
+  }
+  insert() {
+    return new InsertBuilder(this.connection);
+  }
+  update() {
+    return new UpdateBuilder(this.connection);
+  }
+  delete() {
+    return new DeleteBuilder(this.connection);
+  }
+  nextval(name) {
+    return new NextvalBuilder(name, this.connection);
+  }
+  create() {
+    return new CreateBuilder(this.connection);
+  }
+  drop() {
+    return new DropBuilder(this.connection);
+  }
+}
+class SelectBuilder extends AbstractSQLBuilder {
+  prepareBuilder(builder) {
+    return builder.select();
+  }
+  distinct() {
+    this.native.distinct();
+    return this;
+  }
+  forUpdate() {
+    this.native.forUpdate();
+    return this;
+  }
+  column(column) {
+    this.native.column(column);
+    return this;
+  }
+  from(table, alias) {
+    this.native.from(table, alias);
+    return this;
+  }
+  // NOTE: The original JS logic for parameter handling in joins is complex and relies on
+  // argument count. We replicate this behavior by using the optional parameters argument.
+  join(table, on, alias, parameters) {
+    this.native.join(table, on, alias);
+    if (arguments.length > 3) {
+      this.addParameter(arguments[3]);
+    } else if (arguments.length > 2) {
+      this.addParameter(arguments[2]);
+    }
+    return this;
+  }
+  innerJoin(table, on, alias, parameters) {
+    this.native.innerJoin(table, on, alias);
+    if (arguments.length > 3) {
+      this.addParameter(arguments[3]);
+    } else if (arguments.length > 2) {
+      this.addParameter(arguments[2]);
+    }
+    return this;
+  }
+  outerJoin(table, on, alias, parameters) {
+    this.native.outerJoin(table, on, alias);
+    if (arguments.length > 3) {
+      this.addParameter(arguments[3]);
+    } else if (arguments.length > 2) {
+      this.addParameter(arguments[2]);
+    }
+    return this;
+  }
+  leftJoin(table, on, alias, parameters) {
+    this.native.leftJoin(table, on, alias);
+    if (arguments.length > 3) {
+      this.addParameter(arguments[3]);
+    } else if (arguments.length > 2) {
+      this.addParameter(arguments[2]);
+    }
+    return this;
+  }
+  rightJoin(table, on, alias, parameters) {
+    this.native.rightJoin(table, on, alias);
+    if (arguments.length > 3) {
+      this.addParameter(arguments[3]);
+    } else if (arguments.length > 2) {
+      this.addParameter(arguments[2]);
+    }
+    return this;
+  }
+  fullJoin(table, on, alias, parameters) {
+    this.native.fullJoin(table, on, alias);
+    if (arguments.length > 3) {
+      this.addParameter(arguments[3]);
+    } else if (arguments.length > 2) {
+      this.addParameter(arguments[2]);
+    }
+    return this;
+  }
+  /**
+   * Sets the WHERE condition.
+   * @param condition The SQL condition string (e.g., "column1 = ?").
+   * @param parameters Optional parameters to replace '?' in the condition.
+   */
+  where(condition, parameters) {
+    this.native.where(condition);
+    this.addParameter(parameters);
+    return this;
+  }
+  order(column, asc = true) {
+    this.native.order(column, asc);
+    return this;
+  }
+  group(column) {
+    this.native.group(column);
+    return this;
+  }
+  limit(limit) {
+    this.native.limit(limit);
+    return this;
+  }
+  offset(offset) {
+    this.native.offset(offset);
+    return this;
+  }
+  having(having) {
+    this.native.having(having);
+    return this;
+  }
+  union(select) {
+    this.native.union(select);
+    return this;
+  }
+}
+class InsertBuilder extends AbstractSQLBuilder {
+  prepareBuilder(builder) {
+    return builder.insert();
+  }
+  into(table) {
+    this.native.into(table);
+    return this;
+  }
+  column(column) {
+    this.native.column(column);
+    return this;
+  }
+  /**
+   * Sets the value for the last column specified.
+   * @param value The value placeholder (e.g., "?") or literal.
+   * @param parameters Optional parameters if a placeholder was used.
+   */
+  value(value, parameters) {
+    this.native.value(value);
+    this.addParameter(parameters);
+    return this;
+  }
+  select(select) {
+    this.native.select(select);
+    return this;
+  }
+}
+class UpdateBuilder extends AbstractSQLBuilder {
+  prepareBuilder(builder) {
+    return builder.update();
+  }
+  table(table) {
+    this.native.table(table);
+    return this;
+  }
+  /**
+   * Sets a column to a value.
+   * @param column The column name.
+   * @param value The value placeholder (e.g., "?") or literal.
+   * @param parameters Optional parameters if a placeholder was used.
+   */
+  set(column, value, parameters) {
+    this.native.set(column, value);
+    this.addParameter(parameters);
+    return this;
+  }
+  /**
+   * Sets the WHERE condition for the update.
+   * @param condition The SQL condition string (e.g., "column1 = ?").
+   * @param parameters Optional parameters to replace '?' in the condition.
+   */
+  where(condition, parameters) {
+    this.native.where(condition);
+    this.addParameter(parameters);
+    return this;
+  }
+}
+class DeleteBuilder extends AbstractSQLBuilder {
+  prepareBuilder(builder) {
+    return builder.delete();
+  }
+  from(table) {
+    this.native.from(table);
+    return this;
+  }
+  /**
+   * Sets the WHERE condition for the deletion.
+   * @param condition The SQL condition string (e.g., "column1 = ?").
+   * @param parameters Optional parameters to replace '?' in the condition.
+   */
+  where(condition, parameters) {
+    this.native.where(condition);
+    this.addParameter(parameters);
+    return this;
+  }
+}
+class NextvalBuilder extends AbstractSQLBuilder {
+  constructor(name, connection) {
+    super(connection);
+    this.name = name;
+  }
+  prepareBuilder(builder) {
+    return builder.nextval(this.name);
+  }
+}
+class CreateBuilder extends AbstractSQLBuilder {
+  table(table) {
+    console.error(`Table in CreateBuilder is: ${table}`);
+    return new CreateTableBuilder(table, this.connection);
+  }
+  view(view) {
+    return new CreateViewBuilder(view, this.connection);
+  }
+  sequence(sequence) {
+    return new CreateSequenceBuilder(sequence, this.connection);
+  }
+}
+class CreateTableBuilder extends AbstractSQLBuilder {
+  // Overrides constructor to immediately start the native table builder
+  constructor(table, connection) {
+    super(connection);
+    this.native = this.native.create().table(table);
+  }
+  /**
+   * Adds a generic column definition.
+   * @param args Additional dialect-specific arguments passed as an array to native.
+   */
+  column(name, type, isPrimaryKey = false, isNullable = true, isUnique = false, isIdentity = false, isFuzzyIndexEnabled = false, ...args) {
+    const dataType = DataTypeEnum.valueOfByName(type);
+    this.native.column(name, dataType, isPrimaryKey, isNullable, isUnique, isIdentity, isFuzzyIndexEnabled, Array.from(args));
+    return this;
+  }
+  /**
+   * Adds a VARCHAR column.
+   * @param args Additional dialect-specific arguments passed as an array to native.
+   */
+  columnVarchar(name, length, isPrimaryKey = false, isNullable = true, isUnique = false, isIdentity = false, ...args) {
+    this.native.columnVarchar(name, length, isPrimaryKey, isNullable, isUnique, isIdentity, Array.from(args));
+    return this;
+  }
+  /**
+   * Adds an NVARCHAR column.
+   * @param args Additional dialect-specific arguments passed as an array to native.
+   */
+  columnNvarchar(name, length, isPrimaryKey = false, isNullable = true, isUnique = false, isIdentity = false, ...args) {
+    this.native.columnNvarchar(name, length, isPrimaryKey, isNullable, isUnique, isIdentity, Array.from(args));
+    return this;
+  }
+  /**
+   * Adds a CHAR column.
+   * @param args Additional dialect-specific arguments passed as an array to native.
+   */
+  columnChar(name, length, isPrimaryKey = false, isNullable = true, isUnique = false, isIdentity = false, ...args) {
+    this.native.columnChar(name, length, isPrimaryKey, isNullable, isUnique, isIdentity, Array.from(args));
+    return this;
+  }
+  /**
+   * Adds a DATE column.
+   * @param args Additional dialect-specific arguments passed as an array to native.
+   */
+  columnDate(name, isPrimaryKey = false, isNullable = true, isUnique = false, ...args) {
+    this.native.columnDate(name, isPrimaryKey, isNullable, isUnique, Array.from(args));
+    return this;
+  }
+  /**
+   * Adds a TIME column.
+   * @param args Additional dialect-specific arguments passed as an array to native.
+   */
+  columnTime(name, isPrimaryKey = false, isNullable = true, isUnique = false, ...args) {
+    this.native.columnTime(name, isPrimaryKey, isNullable, isUnique, Array.from(args));
+    return this;
+  }
+  /**
+   * Adds a TIMESTAMP column.
+   * @param args Additional dialect-specific arguments passed as an array to native.
+   */
+  columnTimestamp(name, isPrimaryKey = false, isNullable = true, isUnique = false, ...args) {
+    this.native.columnTimestamp(name, isPrimaryKey, isNullable, isUnique, Array.from(args));
+    return this;
+  }
+  /**
+   * Adds an INTEGER column.
+   * @param args Additional dialect-specific arguments passed as an array to native.
+   */
+  columnInteger(name, isPrimaryKey = false, isNullable = true, isUnique = false, isIdentity = false, ...args) {
+    this.native.columnInteger(name, isPrimaryKey, isNullable, isUnique, isIdentity, Array.from(args));
+    return this;
+  }
+  /**
+   * Adds a TINYINT column.
+   * @param args Additional dialect-specific arguments passed as an array to native.
+   */
+  columnTinyint(name, isPrimaryKey = false, isNullable = true, isUnique = false, ...args) {
+    this.native.columnTinyint(name, isPrimaryKey, isNullable, isUnique, Array.from(args));
+    return this;
+  }
+  /**
+   * Adds a BIGINT column.
+   * @param args Additional dialect-specific arguments passed as an array to native.
+   */
+  columnBigint(name, isPrimaryKey = false, isNullable = true, isUnique = false, isIdentity = false, ...args) {
+    this.native.columnBigint(name, isPrimaryKey, isNullable, isUnique, isIdentity, Array.from(args));
+    return this;
+  }
+  /**
+   * Adds a SMALLINT column.
+   * @param args Additional dialect-specific arguments passed as an array to native.
+   */
+  columnSmallint(name, isPrimaryKey = false, isNullable = true, isUnique = false, ...args) {
+    this.native.columnSmallint(name, isPrimaryKey, isNullable, isUnique, Array.from(args));
+    return this;
+  }
+  /**
+   * Adds a REAL column.
+   * @param args Additional dialect-specific arguments passed as an array to native.
+   */
+  columnReal(name, isPrimaryKey = false, isNullable = true, isUnique = false, ...args) {
+    this.native.columnReal(name, isPrimaryKey, isNullable, isUnique, Array.from(args));
+    return this;
+  }
+  /**
+   * Adds a DOUBLE column.
+   * @param args Additional dialect-specific arguments passed as an array to native.
+   */
+  columnDouble(name, isPrimaryKey = false, isNullable = true, isUnique = false, ...args) {
+    this.native.columnDouble(name, isPrimaryKey, isNullable, isUnique, Array.from(args));
+    return this;
+  }
+  /**
+   * Adds a BOOLEAN column.
+   * @param args Additional dialect-specific arguments passed as an array to native.
+   */
+  columnBoolean(name, isPrimaryKey = false, isNullable = true, isUnique = false, ...args) {
+    this.native.columnBoolean(name, isPrimaryKey, isNullable, isUnique, Array.from(args));
+    return this;
+  }
+  /**
+   * Adds a BLOB column.
+   * @param args Additional dialect-specific arguments passed as an array to native.
+   */
+  columnBlob(name, isNullable = true, ...args) {
+    this.native.columnBlob(name, isNullable, Array.from(args));
+    return this;
+  }
+  /**
+   * Adds a DECIMAL column with precision and scale.
+   * @param args Additional dialect-specific arguments passed as an array to native.
+   */
+  columnDecimal(name, precision, scale, isPrimaryKey = false, isNullable = true, isUnique = false, isIdentity = false, ...args) {
+    this.native.columnDecimal(name, precision, scale, isPrimaryKey, isNullable, isUnique, isIdentity, Array.from(args));
+    return this;
+  }
+  primaryKey(columns, name) {
+    this.native.primaryKey(name, columns);
+    return this;
+  }
+  foreignKey(name, columns, referencedTable, referencedColumns, referencedTableSchema) {
+    this.native.foreignKey(name, columns, referencedTable, referencedTableSchema, referencedColumns);
+    return this;
+  }
+  unique(name, columns) {
+    this.native.unique(name, columns);
+    return this;
+  }
+  check(name, expression) {
+    this.native.check(name, expression);
+    return this;
+  }
+}
+class CreateViewBuilder extends AbstractSQLBuilder {
+  constructor(view, connection) {
+    super(connection);
+    this.native = this.native.create().view(view);
+  }
+  column(column) {
+    this.native.column(column);
+    return this;
+  }
+  asSelect(select) {
+    this.native.asSelect(select);
+    return this;
+  }
+}
+class CreateSequenceBuilder extends AbstractSQLBuilder {
+  constructor(sequence, connection) {
+    super(connection);
+    this.native = this.native.create().sequence(sequence);
+  }
+}
+class DropBuilder extends AbstractSQLBuilder {
+  table(table) {
+    return new DropTableBuilder(table, this.connection);
+  }
+  view(view) {
+    return new DropViewBuilder(view, this.connection);
+  }
+  sequence(sequence) {
+    return new DropSequenceBuilder(sequence, this.connection);
+  }
+}
+class DropTableBuilder extends AbstractSQLBuilder {
+  constructor(table, connection) {
+    super(connection);
+    this.native = this.native.drop().table(table);
+  }
+}
+class DropViewBuilder extends AbstractSQLBuilder {
+  constructor(view, connection) {
+    super(connection);
+    this.native = this.native.drop().view(view);
+  }
+}
+class DropSequenceBuilder extends AbstractSQLBuilder {
+  constructor(sequence, connection) {
+    super(connection);
+    this.native = this.native.drop().sequence(sequence);
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = SQLBuilder;
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/db/sql.ts"],
  "sourcesContent": ["import { Connection } from \"./database\";\n\n// Assumed imports for the native Java API calls\nconst DatabaseFacade = Java.type(\"org.eclipse.dirigible.components.api.db.DatabaseFacade\");\nconst DataTypeEnum = Java.type(\"org.eclipse.dirigible.database.sql.DataType\");\n\n/**\n * Union type representing all supported SQL data types.\n */\nexport type DataType =\n\t\"VARCHAR\"\n\t| \"TEXT\"\n\t| \"CHAR\"\n\t| \"DATE\"\n\t| \"SECONDDATE\"\n\t| \"TIME\"\n\t| \"DATETIME\"\n\t| \"TIMESTAMP\"\n\t| \"INTEGER\"\n\t| \"INT\"\n\t| \"TINYINT\"\n\t| \"BIGINT\"\n\t| \"SMALLINT\"\n\t| \"REAL\"\n\t| \"DOUBLE\"\n\t| \"DOUBLE PRECISIO\"\n\t| \"BOOLEAN\"\n\t| \"BLOB\"\n\t| \"DECIMAL\"\n\t| \"BIT\"\n\t| \"NVARCHAR\"\n\t| \"FLOAT\"\n\t| \"BYTE\"\n\t| \"NCLOB\"\n\t| \"ARRAY\"\n\t| \"VARBINARY\"\n\t| \"BINARY VARYIN\"\n\t| \"SHORTTEXT\"\n\t| \"ALPHANUM\"\n\t| \"CLOB\"\n\t| \"SMALLDECIMAL\"\n\t| \"BINARY\"\n\t| \"ST_POINT\"\n\t| \"ST_GEOMETRY\"\n\t| \"CHARACTER VARYIN\"\n\t| \"BINARY LARG OBJECT\"\n\t| \"CHARACTER LARG OBJECT\"\n\t| \"CHARACTER\"\n\t| \"NCHAR\"\n\t| \"NUMERIC\";\n\n/**\n * Abstract base class for all SQL builders. Handles connection, native facade,\n * and parameter collection.\n */\nabstract class AbstractSQLBuilder {\n\n\tpublic readonly params: any[] = [];\n\tprotected readonly connection?: Connection;\n\tprotected native: any; // The underlying Java SQL Builder object\n\n\tconstructor(connection?: Connection) {\n\t\tthis.connection = connection;\n\t\t// Initialize the native builder from the facade\n\t\tthis.native = connection ? DatabaseFacade.getNative((connection as any).native) : DatabaseFacade.getDefault();\n\t\tthis.native = this.prepareBuilder(this.native);\n\t}\n\n\t/**\n\t * Hook for subclasses to set up the native builder object (e.g., calling .select()).\n\t */\n\tprotected prepareBuilder(builder: any): any {\n\t\treturn builder;\n\t}\n\n\tpublic parameters(): any[] {\n\t\treturn this.params;\n\t}\n\n\t/**\n\t * Adds parameter(s) to the internal list. Handles single values and arrays of values.\n\t */\n\tprotected addParameter(value: any | any[]): void {\n\t\tif (value === undefined || value === null) {\n\t\t\treturn; // Do not add undefined/null unless explicitly an array\n\t\t}\n\t\tif (Array.isArray(value)) {\n\t\t\tthis.params.push(...value);\n\t\t} else {\n\t\t\tthis.params.push(value);\n\t\t}\n\t}\n\n\t/**\n\t * Builds and returns the final SQL string.\n\t */\n\tpublic build(): string {\n\t\treturn this.native.build();\n\t}\n}\n\n/**\n * Main entry point for the SQL Builder. Acts as a factory for specific builders.\n */\nexport class SQLBuilder extends AbstractSQLBuilder {\n\n\t/**\n\t * Factory method to get a dialect-specific SQLBuilder instance.\n\t */\n\tpublic static getDialect(connection?: Connection): SQLBuilder {\n\t\treturn new SQLBuilder(connection);\n\t}\n\n\tpublic select(): SelectBuilder {\n\t\treturn new SelectBuilder(this.connection);\n\t}\n\n\tpublic insert(): InsertBuilder {\n\t\treturn new InsertBuilder(this.connection);\n\t}\n\n\tpublic update(): UpdateBuilder {\n\t\treturn new UpdateBuilder(this.connection);\n\t}\n\n\tpublic delete(): DeleteBuilder {\n\t\treturn new DeleteBuilder(this.connection);\n\t}\n\n\tpublic nextval(name: string): NextvalBuilder {\n\t\treturn new NextvalBuilder(name, this.connection);\n\t}\n\n\tpublic create(): CreateBuilder {\n\t\treturn new CreateBuilder(this.connection);\n\t}\n\n\tpublic drop(): DropBuilder {\n\t\treturn new DropBuilder(this.connection);\n\t}\n}\n\n/**\n * Builder for SELECT statements.\n */\nexport class SelectBuilder extends AbstractSQLBuilder {\n\n\tprotected prepareBuilder(builder: any): any {\n\t\treturn builder.select();\n\t}\n\n\tpublic distinct(): SelectBuilder {\n\t\tthis.native.distinct();\n\t\treturn this;\n\t}\n\n\tpublic forUpdate(): SelectBuilder {\n\t\tthis.native.forUpdate();\n\t\treturn this;\n\t}\n\n\tpublic column(column: string): SelectBuilder {\n\t\tthis.native.column(column);\n\t\treturn this;\n\t}\n\n\tpublic from(table: string, alias?: string): SelectBuilder {\n\t\tthis.native.from(table, alias);\n\t\treturn this;\n\t}\n\n\t// NOTE: The original JS logic for parameter handling in joins is complex and relies on\n\t// argument count. We replicate this behavior by using the optional parameters argument.\n\n\tpublic join(table: string, on: string, alias?: string, parameters?: any | any[]): SelectBuilder {\n\t\tthis.native.join(table, on, alias);\n\t\t// arguments[3] is the 4th argument (parameters when alias is present).\n\t\t// arguments[2] is the 3rd argument (parameters when alias is absent).\n\t\t// We use arguments array to maintain compatibility with the original JS implementation.\n\t\tif (arguments.length > 3) {\n\t\t\tthis.addParameter(arguments[3]);\n\t\t} else if (arguments.length > 2) {\n\t\t\t// This branch is highly dependent on how the original code was used:\n\t\t\t// if (alias === undefined && parameters === array): parameters are at arguments[2]\n\t\t\tthis.addParameter(arguments[2]);\n\t\t}\n\t\treturn this;\n\t}\n\n\tpublic innerJoin(table: string, on: string, alias?: string, parameters?: any | any[]): SelectBuilder {\n\t\tthis.native.innerJoin(table, on, alias);\n\t\tif (arguments.length > 3) {\n\t\t\tthis.addParameter(arguments[3]);\n\t\t} else if (arguments.length > 2) {\n\t\t\tthis.addParameter(arguments[2]);\n\t\t}\n\t\treturn this;\n\t}\n\n\tpublic outerJoin(table: string, on: string, alias?: string, parameters?: any | any[]): SelectBuilder {\n\t\tthis.native.outerJoin(table, on, alias);\n\t\tif (arguments.length > 3) {\n\t\t\tthis.addParameter(arguments[3]);\n\t\t} else if (arguments.length > 2) {\n\t\t\tthis.addParameter(arguments[2]);\n\t\t}\n\t\treturn this;\n\t}\n\n\tpublic leftJoin(table: string, on: string, alias?: string, parameters?: any | any[]): SelectBuilder {\n\t\tthis.native.leftJoin(table, on, alias);\n\t\tif (arguments.length > 3) {\n\t\t\tthis.addParameter(arguments[3]);\n\t\t} else if (arguments.length > 2) {\n\t\t\tthis.addParameter(arguments[2]);\n\t\t}\n\t\treturn this;\n\t}\n\n\tpublic rightJoin(table: string, on: string, alias?: string, parameters?: any | any[]): SelectBuilder {\n\t\tthis.native.rightJoin(table, on, alias);\n\t\tif (arguments.length > 3) {\n\t\t\tthis.addParameter(arguments[3]);\n\t\t} else if (arguments.length > 2) {\n\t\t\tthis.addParameter(arguments[2]);\n\t\t}\n\t\treturn this;\n\t}\n\n\tpublic fullJoin(table: string, on: string, alias?: string, parameters?: any | any[]): SelectBuilder {\n\t\tthis.native.fullJoin(table, on, alias);\n\t\tif (arguments.length > 3) {\n\t\t\tthis.addParameter(arguments[3]);\n\t\t} else if (arguments.length > 2) {\n\t\t\tthis.addParameter(arguments[2]);\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Sets the WHERE condition.\n\t * @param condition The SQL condition string (e.g., \"column1 = ?\").\n\t * @param parameters Optional parameters to replace '?' in the condition.\n\t */\n\tpublic where(condition: string, parameters?: any | any[]): SelectBuilder {\n\t\tthis.native.where(condition);\n\t\tthis.addParameter(parameters); // arguments[1] in JS\n\t\treturn this;\n\t}\n\n\tpublic order(column: string, asc: boolean = true): SelectBuilder {\n\t\tthis.native.order(column, asc);\n\t\treturn this;\n\t}\n\n\tpublic group(column: string): SelectBuilder {\n\t\tthis.native.group(column);\n\t\treturn this;\n\t}\n\n\tpublic limit(limit: number): SelectBuilder {\n\t\tthis.native.limit(limit);\n\t\treturn this;\n\t}\n\n\tpublic offset(offset: number): SelectBuilder {\n\t\tthis.native.offset(offset);\n\t\treturn this;\n\t}\n\n\tpublic having(having: string): SelectBuilder {\n\t\tthis.native.having(having);\n\t\treturn this;\n\t}\n\n\tpublic union(select: string): SelectBuilder {\n\t\tthis.native.union(select);\n\t\treturn this;\n\t}\n}\n\n/**\n * Builder for INSERT statements.\n */\nexport class InsertBuilder extends AbstractSQLBuilder {\n\n\tprotected prepareBuilder(builder: any): any {\n\t\treturn builder.insert();\n\t}\n\n\tpublic into(table: string): InsertBuilder {\n\t\tthis.native.into(table);\n\t\treturn this;\n\t}\n\n\tpublic column(column: string): InsertBuilder {\n\t\tthis.native.column(column);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Sets the value for the last column specified.\n\t * @param value The value placeholder (e.g., \"?\") or literal.\n\t * @param parameters Optional parameters if a placeholder was used.\n\t */\n\tpublic value(value: string, parameters?: any | any[]): InsertBuilder {\n\t\tthis.native.value(value);\n\t\tthis.addParameter(parameters); // arguments[1] in JS\n\t\treturn this;\n\t}\n\n\tpublic select(select: string): InsertBuilder {\n\t\tthis.native.select(select);\n\t\treturn this;\n\t}\n}\n\n/**\n * Builder for UPDATE statements.\n */\nexport class UpdateBuilder extends AbstractSQLBuilder {\n\n\tprotected prepareBuilder(builder: any): any {\n\t\treturn builder.update();\n\t}\n\n\tpublic table(table: string): UpdateBuilder {\n\t\tthis.native.table(table);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Sets a column to a value.\n\t * @param column The column name.\n\t * @param value The value placeholder (e.g., \"?\") or literal.\n\t * @param parameters Optional parameters if a placeholder was used.\n\t */\n\tpublic set(column: string, value: string, parameters?: any | any[]): UpdateBuilder {\n\t\tthis.native.set(column, value);\n\t\tthis.addParameter(parameters); // arguments[2] in JS\n\t\treturn this;\n\t}\n\n\t/**\n\t * Sets the WHERE condition for the update.\n\t * @param condition The SQL condition string (e.g., \"column1 = ?\").\n\t * @param parameters Optional parameters to replace '?' in the condition.\n\t */\n\tpublic where(condition: string, parameters?: any | any[]): UpdateBuilder {\n\t\tthis.native.where(condition);\n\t\tthis.addParameter(parameters); // arguments[1] in JS\n\t\treturn this;\n\t}\n}\n\n/**\n * Builder for DELETE statements.\n */\nexport class DeleteBuilder extends AbstractSQLBuilder {\n\n\tprotected prepareBuilder(builder: any): any {\n\t\treturn builder.delete();\n\t}\n\n\tpublic from(table: string): DeleteBuilder {\n\t\tthis.native.from(table);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Sets the WHERE condition for the deletion.\n\t * @param condition The SQL condition string (e.g., \"column1 = ?\").\n\t * @param parameters Optional parameters to replace '?' in the condition.\n\t */\n\tpublic where(condition: string, parameters?: any | any[]): DeleteBuilder {\n\t\tthis.native.where(condition);\n\t\tthis.addParameter(parameters); // arguments[1] in JS\n\t\treturn this;\n\t}\n}\n\n/**\n * Builder for selecting the next value from a sequence.\n */\nexport class NextvalBuilder extends AbstractSQLBuilder {\n\n\tprivate name: string;\n\n\tconstructor(name: string, connection?: Connection) {\n\t\tsuper(connection);\n\t\tthis.name = name;\n\t}\n\n\tprotected prepareBuilder(builder: any): any {\n\t\treturn builder.nextval(this.name);\n\t}\n}\n\n/**\n * Builder for CREATE statements (Table, View, Sequence).\n */\nexport class CreateBuilder extends AbstractSQLBuilder {\n\n\tpublic table(table: string): CreateTableBuilder {\n\t\tconsole.error(`Table in CreateBuilder is: ${table}`);\n\t\treturn new CreateTableBuilder(table, this.connection);\n\t}\n\n\tpublic view(view: string): CreateViewBuilder {\n\t\treturn new CreateViewBuilder(view, this.connection);\n\t}\n\n\tpublic sequence(sequence: string): CreateSequenceBuilder {\n\t\treturn new CreateSequenceBuilder(sequence, this.connection)\n\t}\n}\n\n/**\n * Builder for CREATE TABLE statements.\n */\nexport class CreateTableBuilder extends AbstractSQLBuilder {\n\n\t// Overrides constructor to immediately start the native table builder\n\tconstructor(table: string, connection?: Connection) {\n\t\tsuper(connection);\n\t\tthis.native = this.native.create().table(table);\n\t}\n\n\t/**\n\t * Adds a generic column definition.\n\t * @param args Additional dialect-specific arguments passed as an array to native.\n\t */\n\tpublic column(\n\t\tname: string, \n\t\ttype: DataType, \n\t\tisPrimaryKey = false, \n\t\tisNullable = true, \n\t\tisUnique = false, \n\t\tisIdentity = false, \n\t\tisFuzzyIndexEnabled = false, \n\t\t...args: string[]\n\t): CreateTableBuilder {\n\t\tconst dataType = DataTypeEnum.valueOfByName(type);\n\t\tthis.native.column(name, dataType, isPrimaryKey, isNullable, isUnique, isIdentity, isFuzzyIndexEnabled, Array.from(args));\n\t\treturn this;\n\t}\n\n\t/**\n\t * Adds a VARCHAR column.\n\t * @param args Additional dialect-specific arguments passed as an array to native.\n\t */\n\tpublic columnVarchar(\n\t\tname: string, \n\t\tlength: number, \n\t\tisPrimaryKey = false, \n\t\tisNullable = true, \n\t\tisUnique = false, \n\t\tisIdentity = false, \n\t\t...args: string[]\n\t): CreateTableBuilder {\n\t\tthis.native.columnVarchar(name, length, isPrimaryKey, isNullable, isUnique, isIdentity, Array.from(args));\n\t\treturn this;\n\t}\n\n\t/**\n\t * Adds an NVARCHAR column.\n\t * @param args Additional dialect-specific arguments passed as an array to native.\n\t */\n\tpublic columnNvarchar(\n\t\tname: string, \n\t\tlength: number, \n\t\tisPrimaryKey = false, \n\t\tisNullable = true, \n\t\tisUnique = false, \n\t\tisIdentity = false, \n\t\t...args: string[]\n\t): CreateTableBuilder {\n\t\tthis.native.columnNvarchar(name, length, isPrimaryKey, isNullable, isUnique, isIdentity, Array.from(args));\n\t\treturn this;\n\t}\n\n\t/**\n\t * Adds a CHAR column.\n\t * @param args Additional dialect-specific arguments passed as an array to native.\n\t */\n\tpublic columnChar(\n\t\tname: string, \n\t\tlength: number, \n\t\tisPrimaryKey = false, \n\t\tisNullable = true, \n\t\tisUnique = false, \n\t\tisIdentity = false, \n\t\t...args: string[]\n\t): CreateTableBuilder {\n\t\tthis.native.columnChar(name, length, isPrimaryKey, isNullable, isUnique, isIdentity, Array.from(args));\n\t\treturn this;\n\t}\n\n\t/**\n\t * Adds a DATE column.\n\t * @param args Additional dialect-specific arguments passed as an array to native.\n\t */\n\tpublic columnDate(\n\t\tname: string, \n\t\tisPrimaryKey = false, \n\t\tisNullable = true, \n\t\tisUnique = false, \n\t\t...args: string[]\n\t): CreateTableBuilder {\n\t\tthis.native.columnDate(name, isPrimaryKey, isNullable, isUnique, Array.from(args));\n\t\treturn this;\n\t}\n\n\t/**\n\t * Adds a TIME column.\n\t * @param args Additional dialect-specific arguments passed as an array to native.\n\t */\n\tpublic columnTime(\n\t\tname: string, \n\t\tisPrimaryKey = false, \n\t\tisNullable = true, \n\t\tisUnique = false, \n\t\t...args: string[]\n\t): CreateTableBuilder {\n\t\tthis.native.columnTime(name, isPrimaryKey, isNullable, isUnique, Array.from(args));\n\t\treturn this;\n\t}\n\n\t/**\n\t * Adds a TIMESTAMP column.\n\t * @param args Additional dialect-specific arguments passed as an array to native.\n\t */\n\tpublic columnTimestamp(\n\t\tname: string, \n\t\tisPrimaryKey = false, \n\t\tisNullable = true, \n\t\tisUnique = false, \n\t\t...args: string[]\n\t): CreateTableBuilder {\n\t\tthis.native.columnTimestamp(name, isPrimaryKey, isNullable, isUnique, Array.from(args));\n\t\treturn this;\n\t}\n\n\t/**\n\t * Adds an INTEGER column.\n\t * @param args Additional dialect-specific arguments passed as an array to native.\n\t */\n\tpublic columnInteger(\n\t\tname: string, \n\t\tisPrimaryKey = false, \n\t\tisNullable = true, \n\t\tisUnique = false, \n\t\tisIdentity = false, \n\t\t...args: string[]\n\t): CreateTableBuilder {\n\t\tthis.native.columnInteger(name, isPrimaryKey, isNullable, isUnique, isIdentity, Array.from(args));\n\t\treturn this;\n\t}\n\n\t/**\n\t * Adds a TINYINT column.\n\t * @param args Additional dialect-specific arguments passed as an array to native.\n\t */\n\tpublic columnTinyint(\n\t\tname: string, \n\t\tisPrimaryKey = false, \n\t\tisNullable = true, \n\t\tisUnique = false, \n\t\t...args: string[]\n\t): CreateTableBuilder {\n\t\tthis.native.columnTinyint(name, isPrimaryKey, isNullable, isUnique, Array.from(args));\n\t\treturn this;\n\t}\n\n\t/**\n\t * Adds a BIGINT column.\n\t * @param args Additional dialect-specific arguments passed as an array to native.\n\t */\n\tpublic columnBigint(\n\t\tname: string, \n\t\tisPrimaryKey = false, \n\t\tisNullable = true, \n\t\tisUnique = false, \n\t\tisIdentity = false, \n\t\t...args: string[]\n\t): CreateTableBuilder {\n\t\tthis.native.columnBigint(name, isPrimaryKey, isNullable, isUnique, isIdentity, Array.from(args));\n\t\treturn this;\n\t}\n\n\t/**\n\t * Adds a SMALLINT column.\n\t * @param args Additional dialect-specific arguments passed as an array to native.\n\t */\n\tpublic columnSmallint(\n\t\tname: string, \n\t\tisPrimaryKey = false, \n\t\tisNullable = true, \n\t\tisUnique = false, \n\t\t...args: string[]\n\t): CreateTableBuilder {\n\t\tthis.native.columnSmallint(name, isPrimaryKey, isNullable, isUnique, Array.from(args));\n\t\treturn this;\n\t}\n\n\t/**\n\t * Adds a REAL column.\n\t * @param args Additional dialect-specific arguments passed as an array to native.\n\t */\n\tpublic columnReal(\n\t\tname: string, \n\t\tisPrimaryKey = false, \n\t\tisNullable = true, \n\t\tisUnique = false, \n\t\t...args: string[]\n\t): CreateTableBuilder {\n\t\tthis.native.columnReal(name, isPrimaryKey, isNullable, isUnique, Array.from(args));\n\t\treturn this;\n\t}\n\n\t/**\n\t * Adds a DOUBLE column.\n\t * @param args Additional dialect-specific arguments passed as an array to native.\n\t */\n\tpublic columnDouble(\n\t\tname: string, \n\t\tisPrimaryKey = false, \n\t\tisNullable = true, \n\t\tisUnique = false, \n\t\t...args: string[]\n\t): CreateTableBuilder {\n\t\tthis.native.columnDouble(name, isPrimaryKey, isNullable, isUnique, Array.from(args));\n\t\treturn this;\n\t}\n\n\t/**\n\t * Adds a BOOLEAN column.\n\t * @param args Additional dialect-specific arguments passed as an array to native.\n\t */\n\tpublic columnBoolean(\n\t\tname: string, \n\t\tisPrimaryKey = false, \n\t\tisNullable = true, \n\t\tisUnique = false, \n\t\t...args: string[]\n\t): CreateTableBuilder {\n\t\tthis.native.columnBoolean(name, isPrimaryKey, isNullable, isUnique, Array.from(args));\n\t\treturn this;\n\t}\n\n\t/**\n\t * Adds a BLOB column.\n\t * @param args Additional dialect-specific arguments passed as an array to native.\n\t */\n\tpublic columnBlob(\n\t\tname: string, \n\t\tisNullable = true, \n\t\t...args: string[]\n\t): CreateTableBuilder {\n\t\tthis.native.columnBlob(name, isNullable, Array.from(args));\n\t\treturn this;\n\t}\n\n\t/**\n\t * Adds a DECIMAL column with precision and scale.\n\t * @param args Additional dialect-specific arguments passed as an array to native.\n\t */\n\tpublic columnDecimal(\n\t\tname: string, \n\t\tprecision: number, \n\t\tscale: number, \n\t\tisPrimaryKey = false, \n\t\tisNullable = true, \n\t\tisUnique = false, \n\t\tisIdentity = false, \n\t\t...args: string[]\n\t): CreateTableBuilder {\n\t\tthis.native.columnDecimal(name, precision, scale, isPrimaryKey, isNullable, isUnique, isIdentity, Array.from(args));\n\t\treturn this;\n\t}\n\n\tpublic primaryKey(columns: string[], name?: string): CreateTableBuilder {\n\t\tthis.native.primaryKey(name, columns);\n\t\treturn this;\n\t}\n\n\tpublic foreignKey(name: string, columns: string[], referencedTable: string, referencedColumns: string[], referencedTableSchema?: string): CreateTableBuilder {\n\t\t// NOTE: The native function expects the schema before the referenced columns\n\t\tthis.native.foreignKey(name, columns, referencedTable, referencedTableSchema, referencedColumns);\n\t\treturn this;\n\t}\n\n\tpublic unique(name: string, columns: string[]): CreateTableBuilder {\n\t\tthis.native.unique(name, columns);\n\t\treturn this;\n\t}\n\n\tpublic check(name: string, expression: string): CreateTableBuilder {\n\t\tthis.native.check(name, expression);\n\t\treturn this;\n\t}\n}\n\n/**\n * Builder for CREATE VIEW statements.\n */\nexport class CreateViewBuilder extends AbstractSQLBuilder {\n\n\tconstructor(view: string, connection?: Connection) {\n\t\tsuper(connection);\n\t\tthis.native = this.native.create().view(view);\n\t}\n\n\tpublic column(column: string): CreateViewBuilder {\n\t\tthis.native.column(column);\n\t\treturn this;\n\t}\n\n\tpublic asSelect(select: string): CreateViewBuilder {\n\t\tthis.native.asSelect(select);\n\t\treturn this;\n\t}\n}\n\n/**\n * Builder for CREATE SEQUENCE statements.\n */\nexport class CreateSequenceBuilder extends AbstractSQLBuilder {\n\n\tconstructor(sequence: string, connection?: Connection) {\n\t\tsuper(connection);\n\t\tthis.native = this.native.create().sequence(sequence);\n\t}\n}\n\n/**\n * Builder for DROP statements (Table, View, Sequence).\n */\nexport class DropBuilder extends AbstractSQLBuilder {\n\n\tpublic table(table: string): DropTableBuilder {\n\t\treturn new DropTableBuilder(table, this.connection);\n\t}\n\n\tpublic view(view: string): DropViewBuilder {\n\t\treturn new DropViewBuilder(view, this.connection);\n\t}\n\n\tpublic sequence(sequence: string): DropSequenceBuilder {\n\t\treturn new DropSequenceBuilder(sequence, this.connection);\n\t};\n\n}\n\n/**\n * Builder for DROP TABLE statements.\n */\nexport class DropTableBuilder extends AbstractSQLBuilder {\n\n\tconstructor(table: string, connection?: Connection) {\n\t\tsuper(connection);\n\t\tthis.native = this.native.drop().table(table);\n\t}\n}\n\n/**\n * Builder for DROP VIEW statements.\n */\nexport class DropViewBuilder extends AbstractSQLBuilder {\n\n\tconstructor(view: string, connection?: Connection) {\n\t\tsuper(connection);\n\t\tthis.native = this.native.drop().view(view);\n\t}\n}\n\n/**\n * Builder for DROP SEQUENCE statements.\n */\nexport class DropSequenceBuilder extends AbstractSQLBuilder {\n\n\tconstructor(sequence: string, connection?: Connection) {\n\t\tsuper(connection);\n\t\tthis.native = this.native.drop().sequence(sequence);\n\t}\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = SQLBuilder;\n}"],
  "mappings": "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",
  "names": []
}
