@nextlyhq/adapter-drizzle 0.0.2-alpha.67 → 0.0.2-alpha.69

package/dist/schema-Bkkr3JMC.d.ts

@@ -0,0 +1,264 @@
+/**
+ * Core type definitions for the Nextly database adapter system.
+ *
+ * These types are the foundation for all database operations and are designed
+ * to be database-agnostic while supporting dialect-specific features.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Supported database dialects.
+ *
+ * @remarks
+ * These are the database systems that Nextly officially supports through
+ * dedicated adapter packages.
+ *
+ * @public
+ */
+type SupportedDialect = "postgresql" | "mysql" | "sqlite";
+/**
+ * SQL parameter types that are safe to use across all database dialects.
+ *
+ * @remarks
+ * - `undefined` is included for optional parameters
+ * - `Date` objects will be converted to appropriate format per dialect
+ * - `null` represents SQL NULL
+ *
+ * @public
+ */
+type SqlParam = string | number | boolean | Date | null | undefined;
+/**
+ * JSON value types that can be stored in JSON/JSONB columns.
+ *
+ * @remarks
+ * Represents the valid JSON value types as defined by the JSON specification.
+ * This is a recursive type to support nested objects and arrays.
+ *
+ * @public
+ */
+type JsonValue = string | number | boolean | null | JsonValue[] | {
+  [key: string]: JsonValue;
+};
+/**
+ * JSON object type for structured data.
+ *
+ * @remarks
+ * Useful for typed JSON column data where the structure is known.
+ *
+ * @public
+ */
+type JsonObject = {
+  [key: string]: JsonValue;
+};
+/**
+ * JSON array type.
+ *
+ * @public
+ */
+type JsonArray = JsonValue[];
+/**
+ * Interface for resolving table names to Drizzle table objects.
+ *
+ * @remarks
+ * When a TableResolver is set on the adapter via `setTableResolver()`,
+ * CRUD methods will use Drizzle's query API instead of raw SQL string building.
+ * The nextly SchemaRegistry implements this interface.
+ *
+ * @public
+ */
+interface TableResolver {
+  /** Look up a Drizzle table object by table name. Returns null if not found. */
+  getTable(tableName: string): unknown;
+}
+/**
+ * Column definition for schema operations.
+ *
+ * @remarks
+ * Defines the structure of a database column in a database-agnostic way.
+ * Adapters translate these definitions to dialect-specific DDL.
+ *
+ * @public
+ */
+interface ColumnDefinition {
+  /** Column name */
+  name: string;
+  /**
+   * Column data type.
+   *
+   * @remarks
+   * Common types across databases:
+   * - Text: varchar(n), text, char(n)
+   * - Numbers: int, bigint, decimal, numeric
+   * - Boolean: boolean
+   * - Date/Time: timestamp, date, time
+   * - JSON: json, jsonb (PostgreSQL)
+   * - UUID: uuid (PostgreSQL), char(36) (MySQL/SQLite)
+   *
+   * Adapters handle dialect-specific type mapping.
+   */
+  type: string;
+  /** Allow NULL values (default: true) */
+  nullable?: boolean;
+  /** Primary key column */
+  primaryKey?: boolean;
+  /** Unique constraint */
+  unique?: boolean;
+  /** Default value (literal or SQL expression) */
+  default?: SqlParam | {
+    sql: string;
+  };
+  /** Foreign key reference */
+  references?: {
+    /** Referenced table name */
+    table: string;
+    /** Referenced column name */
+    column: string;
+    /** Action on DELETE */
+    onDelete?: "no action" | "restrict" | "cascade" | "set null" | "set default";
+    /** Action on UPDATE */
+    onUpdate?: "no action" | "restrict" | "cascade" | "set null" | "set default";
+  };
+  /** Check constraint expression */
+  check?: string;
+  /** Generated column definition (computed column) */
+  generated?: {
+    /** SQL expression to generate the value */
+    as: string;
+    /** Store the value (true) or compute on-the-fly (false) */
+    stored?: boolean;
+  };
+}
+/**
+ * Index definition for schema operations.
+ *
+ * @remarks
+ * Defines database indexes for performance optimization.
+ *
+ * @public
+ */
+interface IndexDefinition {
+  /** Index name */
+  name: string;
+  /** Columns included in the index */
+  columns: string[];
+  /** Unique index (enforces uniqueness) */
+  unique?: boolean;
+  /** Partial index condition (WHERE clause) */
+  where?: string;
+  /** Index type (database-specific) */
+  using?: "btree" | "hash" | "gin" | "gist" | "brin";
+}
+/**
+ * Table constraint definition.
+ *
+ * @public
+ */
+interface TableConstraint {
+  /** Constraint name */
+  name: string;
+  /** Constraint type */
+  type: "unique" | "check" | "foreign_key" | "primary_key";
+  /** Columns involved in the constraint */
+  columns?: string[];
+  /** Check constraint expression */
+  expression?: string;
+  /** Foreign key reference (for foreign_key type) */
+  references?: {
+    /** Referenced table name */
+    table: string;
+    /** Referenced columns */
+    columns: string[];
+    /** Action on DELETE */
+    onDelete?: "no action" | "restrict" | "cascade" | "set null" | "set default";
+    /** Action on UPDATE */
+    onUpdate?: "no action" | "restrict" | "cascade" | "set null" | "set default";
+  };
+}
+/**
+ * Complete table definition.
+ *
+ * @remarks
+ * Defines the complete structure of a database table including columns,
+ * indexes, and constraints.
+ *
+ * @public
+ */
+interface TableDefinition {
+  /** Table name */
+  name: string;
+  /** Column definitions */
+  columns: ColumnDefinition[];
+  /** Composite primary key (if not defined at column level) */
+  primaryKey?: string[];
+  /** Index definitions */
+  indexes?: IndexDefinition[];
+  /** Table-level constraints */
+  constraints?: TableConstraint[];
+  /** Table comment/description */
+  comment?: string;
+}
+/**
+ * Options for table creation.
+ *
+ * @public
+ */
+interface CreateTableOptions {
+  /** Don't throw error if table exists */
+  ifNotExists?: boolean;
+  /** Temporary table (session-scoped) */
+  temporary?: boolean;
+}
+/**
+ * Options for table dropping.
+ *
+ * @public
+ */
+interface DropTableOptions {
+  /** Don't throw error if table doesn't exist */
+  ifExists?: boolean;
+  /** Drop dependent objects (CASCADE) */
+  cascade?: boolean;
+  /** Restrict drop if dependencies exist (default) */
+  restrict?: boolean;
+}
+/**
+ * Options for table alteration.
+ *
+ * @public
+ */
+interface AlterTableOptions {
+  /** Validation mode for constraints */
+  validate?: boolean;
+}
+/**
+ * Table alteration operations.
+ *
+ * @remarks
+ * Defines the types of operations that can be performed when altering a table.
+ *
+ * @public
+ */
+type AlterTableOperation = {
+  kind: "add_column";
+  column: ColumnDefinition;
+} | {
+  kind: "drop_column";
+  columnName: string;
+  cascade?: boolean;
+} | {
+  kind: "rename_column";
+  from: string;
+  to: string;
+} | {
+  kind: "modify_column";
+  column: ColumnDefinition;
+} | {
+  kind: "add_constraint";
+  constraint: TableConstraint;
+} | {
+  kind: "drop_constraint";
+  constraintName: string;
+  cascade?: boolean;
+};
+export { DropTableOptions as a, TableDefinition as c, JsonValue as d, SqlParam as f, CreateTableOptions as i, JsonArray as l, TableResolver as m, AlterTableOptions as n, IndexDefinition as o, SupportedDialect as p, ColumnDefinition as r, TableConstraint as s, AlterTableOperation as t, JsonObject as u };
+//# sourceMappingURL=schema-Bkkr3JMC.d.ts.map

package/dist/schema-name.cjs

@@ -1,20 +1,42 @@
-'use strict';
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 // src/schema-name.ts
-var IDENTIFIER = /^[a-z_][a-z0-9_]{0,62}$/;
+/**
+* The one rule for a PostgreSQL schema name.
+*
+* Lives in the adapter package because both sides need it and neither may
+* import the other: `nextly` validates the configured value at boot so the
+* error names the setting, and the Postgres adapter validates again at the
+* point of interpolation, because that is where a bad value becomes SQL.
+*
+* @module schema-name
+* @since 1.0.0
+*/
+/**
+* A plain, lower-case identifier.
+*
+* Checked rather than quoted because the value is interpolated into
+* `search_path` and `CREATE SCHEMA`, where a quoted-but-hostile name is still
+* a name somebody else chose. Refusing the shapes that need quoting costs
+* nothing real and removes the question entirely.
+*/
+const IDENTIFIER = /^[a-z_][a-z0-9_]{0,62}$/;
+/** Whether this is a name the adapter will interpolate. */
 function isValidSchemaName(name) {
-  return IDENTIFIER.test(name) && !name.startsWith("pg_");
+	return IDENTIFIER.test(name) && !name.startsWith("pg_");
 }
+/**
+* Return the name, or throw rather than interpolate something unchecked.
+*
+* The adapter throws a plain Error: it has no access to the config path that
+* produced the value, and `nextly` already refuses the same shapes at boot
+* with a message that names `db.postgres.schema`. This is the backstop for a
+* caller that constructed the adapter directly.
+*/
 function assertSchemaName(name) {
-  if (!isValidSchemaName(name)) {
-    throw new Error(
-      `Invalid PostgreSQL schema name "${name}". Use lower-case letters, digits and underscores, starting with a letter or underscore (max 63 characters), and not beginning with "pg_".`
-    );
-  }
-  return name;
+	if (!isValidSchemaName(name)) throw new Error(`Invalid PostgreSQL schema name "${name}". Use lower-case letters, digits and underscores, starting with a letter or underscore (max 63 characters), and not beginning with "pg_".`);
+	return name;
 }
-
 exports.assertSchemaName = assertSchemaName;
 exports.isValidSchemaName = isValidSchemaName;
-//# sourceMappingURL=schema-name.cjs.map
+
 //# sourceMappingURL=schema-name.cjs.map

package/dist/schema-name.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/schema-name.ts"],"names":[],"mappings":";;;AAoBA,IAAM,UAAA,GAAa,yBAAA;AAGZ,SAAS,kBAAkB,IAAA,EAAuB;AAEvD,EAAA,OAAO,WAAW,IAAA,CAAK,IAAI,KAAK,CAAC,IAAA,CAAK,WAAW,KAAK,CAAA;AACxD;AAUO,SAAS,iBAAiB,IAAA,EAAsB;AACrD,EAAA,IAAI,CAAC,iBAAA,CAAkB,IAAI,CAAA,EAAG;AAC5B,IAAA,MAAM,IAAI,KAAA;AAAA,MACR,mCAAmC,IAAI,CAAA,0IAAA;AAAA,KACzC;AAAA,EACF;AACA,EAAA,OAAO,IAAA;AACT","file":"schema-name.cjs","sourcesContent":["/**\n * The one rule for a PostgreSQL schema name.\n *\n * Lives in the adapter package because both sides need it and neither may\n * import the other: `nextly` validates the configured value at boot so the\n * error names the setting, and the Postgres adapter validates again at the\n * point of interpolation, because that is where a bad value becomes SQL.\n *\n * @module schema-name\n * @since 1.0.0\n */\n\n/**\n * A plain, lower-case identifier.\n *\n * Checked rather than quoted because the value is interpolated into\n * `search_path` and `CREATE SCHEMA`, where a quoted-but-hostile name is still\n * a name somebody else chose. Refusing the shapes that need quoting costs\n * nothing real and removes the question entirely.\n */\nconst IDENTIFIER = /^[a-z_][a-z0-9_]{0,62}$/;\n\n/** Whether this is a name the adapter will interpolate. */\nexport function isValidSchemaName(name: string): boolean {\n  // `pg_` is PostgreSQL's reserved prefix for system catalogs.\n  return IDENTIFIER.test(name) && !name.startsWith(\"pg_\");\n}\n\n/**\n * Return the name, or throw rather than interpolate something unchecked.\n *\n * The adapter throws a plain Error: it has no access to the config path that\n * produced the value, and `nextly` already refuses the same shapes at boot\n * with a message that names `db.postgres.schema`. This is the backstop for a\n * caller that constructed the adapter directly.\n */\nexport function assertSchemaName(name: string): string {\n  if (!isValidSchemaName(name)) {\n    throw new Error(\n      `Invalid PostgreSQL schema name \"${name}\". Use lower-case letters, digits and underscores, starting with a letter or underscore (max 63 characters), and not beginning with \"pg_\".`\n    );\n  }\n  return name;\n}\n"]}
+{"version":3,"file":"schema-name.cjs","names":[],"sources":["../src/schema-name.ts"],"sourcesContent":["/**\n * The one rule for a PostgreSQL schema name.\n *\n * Lives in the adapter package because both sides need it and neither may\n * import the other: `nextly` validates the configured value at boot so the\n * error names the setting, and the Postgres adapter validates again at the\n * point of interpolation, because that is where a bad value becomes SQL.\n *\n * @module schema-name\n * @since 1.0.0\n */\n\n/**\n * A plain, lower-case identifier.\n *\n * Checked rather than quoted because the value is interpolated into\n * `search_path` and `CREATE SCHEMA`, where a quoted-but-hostile name is still\n * a name somebody else chose. Refusing the shapes that need quoting costs\n * nothing real and removes the question entirely.\n */\nconst IDENTIFIER = /^[a-z_][a-z0-9_]{0,62}$/;\n\n/** Whether this is a name the adapter will interpolate. */\nexport function isValidSchemaName(name: string): boolean {\n  // `pg_` is PostgreSQL's reserved prefix for system catalogs.\n  return IDENTIFIER.test(name) && !name.startsWith(\"pg_\");\n}\n\n/**\n * Return the name, or throw rather than interpolate something unchecked.\n *\n * The adapter throws a plain Error: it has no access to the config path that\n * produced the value, and `nextly` already refuses the same shapes at boot\n * with a message that names `db.postgres.schema`. This is the backstop for a\n * caller that constructed the adapter directly.\n */\nexport function assertSchemaName(name: string): string {\n  if (!isValidSchemaName(name)) {\n    throw new Error(\n      `Invalid PostgreSQL schema name \"${name}\". Use lower-case letters, digits and underscores, starting with a letter or underscore (max 63 characters), and not beginning with \"pg_\".`\n    );\n  }\n  return name;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAoBA,MAAM,aAAa;;AAGnB,SAAgB,kBAAkB,MAAuB;CAEvD,OAAO,WAAW,KAAK,IAAI,KAAK,CAAC,KAAK,WAAW,KAAK;AACxD;;;;;;;;;AAUA,SAAgB,iBAAiB,MAAsB;CACrD,IAAI,CAAC,kBAAkB,IAAI,GACzB,MAAM,IAAI,MACR,mCAAmC,KAAK,2IAC1C;CAEF,OAAO;AACT"}

package/dist/schema-name.d.cts

@@ -1,16 +1,5 @@
-/**
- * The one rule for a PostgreSQL schema name.
- *
- * Lives in the adapter package because both sides need it and neither may
- * import the other: `nextly` validates the configured value at boot so the
- * error names the setting, and the Postgres adapter validates again at the
- * point of interpolation, because that is where a bad value becomes SQL.
- *
- * @module schema-name
- * @since 1.0.0
- */
 /** Whether this is a name the adapter will interpolate. */
-declare function isValidSchemaName(name: string): boolean;
+export declare function isValidSchemaName(name: string): boolean;
 /**
  * Return the name, or throw rather than interpolate something unchecked.
  *
@@ -19,6 +8,5 @@ declare function isValidSchemaName(name: string): boolean;
  * with a message that names `db.postgres.schema`. This is the backstop for a
  * caller that constructed the adapter directly.
  */
-declare function assertSchemaName(name: string): string;
-
-export { assertSchemaName, isValidSchemaName };
+export declare function assertSchemaName(name: string): string;
+//# sourceMappingURL=schema-name.d.cts.map

package/dist/schema-name.d.ts

@@ -1,16 +1,5 @@
-/**
- * The one rule for a PostgreSQL schema name.
- *
- * Lives in the adapter package because both sides need it and neither may
- * import the other: `nextly` validates the configured value at boot so the
- * error names the setting, and the Postgres adapter validates again at the
- * point of interpolation, because that is where a bad value becomes SQL.
- *
- * @module schema-name
- * @since 1.0.0
- */
 /** Whether this is a name the adapter will interpolate. */
-declare function isValidSchemaName(name: string): boolean;
+export declare function isValidSchemaName(name: string): boolean;
 /**
  * Return the name, or throw rather than interpolate something unchecked.
  *
@@ -19,6 +8,5 @@ declare function isValidSchemaName(name: string): boolean;
  * with a message that names `db.postgres.schema`. This is the backstop for a
  * caller that constructed the adapter directly.
  */
-declare function assertSchemaName(name: string): string;
-
-export { assertSchemaName, isValidSchemaName };
+export declare function assertSchemaName(name: string): string;
+//# sourceMappingURL=schema-name.d.ts.map

package/dist/schema-name.mjs

@@ -1,17 +1,40 @@
 // src/schema-name.ts
-var IDENTIFIER = /^[a-z_][a-z0-9_]{0,62}$/;
+/**
+* The one rule for a PostgreSQL schema name.
+*
+* Lives in the adapter package because both sides need it and neither may
+* import the other: `nextly` validates the configured value at boot so the
+* error names the setting, and the Postgres adapter validates again at the
+* point of interpolation, because that is where a bad value becomes SQL.
+*
+* @module schema-name
+* @since 1.0.0
+*/
+/**
+* A plain, lower-case identifier.
+*
+* Checked rather than quoted because the value is interpolated into
+* `search_path` and `CREATE SCHEMA`, where a quoted-but-hostile name is still
+* a name somebody else chose. Refusing the shapes that need quoting costs
+* nothing real and removes the question entirely.
+*/
+const IDENTIFIER = /^[a-z_][a-z0-9_]{0,62}$/;
+/** Whether this is a name the adapter will interpolate. */
 function isValidSchemaName(name) {
-  return IDENTIFIER.test(name) && !name.startsWith("pg_");
+	return IDENTIFIER.test(name) && !name.startsWith("pg_");
 }
+/**
+* Return the name, or throw rather than interpolate something unchecked.
+*
+* The adapter throws a plain Error: it has no access to the config path that
+* produced the value, and `nextly` already refuses the same shapes at boot
+* with a message that names `db.postgres.schema`. This is the backstop for a
+* caller that constructed the adapter directly.
+*/
 function assertSchemaName(name) {
-  if (!isValidSchemaName(name)) {
-    throw new Error(
-      `Invalid PostgreSQL schema name "${name}". Use lower-case letters, digits and underscores, starting with a letter or underscore (max 63 characters), and not beginning with "pg_".`
-    );
-  }
-  return name;
+	if (!isValidSchemaName(name)) throw new Error(`Invalid PostgreSQL schema name "${name}". Use lower-case letters, digits and underscores, starting with a letter or underscore (max 63 characters), and not beginning with "pg_".`);
+	return name;
 }
-
 export { assertSchemaName, isValidSchemaName };
-//# sourceMappingURL=schema-name.mjs.map
+
 //# sourceMappingURL=schema-name.mjs.map

package/dist/schema-name.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/schema-name.ts"],"names":[],"mappings":";AAoBA,IAAM,UAAA,GAAa,yBAAA;AAGZ,SAAS,kBAAkB,IAAA,EAAuB;AAEvD,EAAA,OAAO,WAAW,IAAA,CAAK,IAAI,KAAK,CAAC,IAAA,CAAK,WAAW,KAAK,CAAA;AACxD;AAUO,SAAS,iBAAiB,IAAA,EAAsB;AACrD,EAAA,IAAI,CAAC,iBAAA,CAAkB,IAAI,CAAA,EAAG;AAC5B,IAAA,MAAM,IAAI,KAAA;AAAA,MACR,mCAAmC,IAAI,CAAA,0IAAA;AAAA,KACzC;AAAA,EACF;AACA,EAAA,OAAO,IAAA;AACT","file":"schema-name.mjs","sourcesContent":["/**\n * The one rule for a PostgreSQL schema name.\n *\n * Lives in the adapter package because both sides need it and neither may\n * import the other: `nextly` validates the configured value at boot so the\n * error names the setting, and the Postgres adapter validates again at the\n * point of interpolation, because that is where a bad value becomes SQL.\n *\n * @module schema-name\n * @since 1.0.0\n */\n\n/**\n * A plain, lower-case identifier.\n *\n * Checked rather than quoted because the value is interpolated into\n * `search_path` and `CREATE SCHEMA`, where a quoted-but-hostile name is still\n * a name somebody else chose. Refusing the shapes that need quoting costs\n * nothing real and removes the question entirely.\n */\nconst IDENTIFIER = /^[a-z_][a-z0-9_]{0,62}$/;\n\n/** Whether this is a name the adapter will interpolate. */\nexport function isValidSchemaName(name: string): boolean {\n  // `pg_` is PostgreSQL's reserved prefix for system catalogs.\n  return IDENTIFIER.test(name) && !name.startsWith(\"pg_\");\n}\n\n/**\n * Return the name, or throw rather than interpolate something unchecked.\n *\n * The adapter throws a plain Error: it has no access to the config path that\n * produced the value, and `nextly` already refuses the same shapes at boot\n * with a message that names `db.postgres.schema`. This is the backstop for a\n * caller that constructed the adapter directly.\n */\nexport function assertSchemaName(name: string): string {\n  if (!isValidSchemaName(name)) {\n    throw new Error(\n      `Invalid PostgreSQL schema name \"${name}\". Use lower-case letters, digits and underscores, starting with a letter or underscore (max 63 characters), and not beginning with \"pg_\".`\n    );\n  }\n  return name;\n}\n"]}
+{"version":3,"file":"schema-name.mjs","names":[],"sources":["../src/schema-name.ts"],"sourcesContent":["/**\n * The one rule for a PostgreSQL schema name.\n *\n * Lives in the adapter package because both sides need it and neither may\n * import the other: `nextly` validates the configured value at boot so the\n * error names the setting, and the Postgres adapter validates again at the\n * point of interpolation, because that is where a bad value becomes SQL.\n *\n * @module schema-name\n * @since 1.0.0\n */\n\n/**\n * A plain, lower-case identifier.\n *\n * Checked rather than quoted because the value is interpolated into\n * `search_path` and `CREATE SCHEMA`, where a quoted-but-hostile name is still\n * a name somebody else chose. Refusing the shapes that need quoting costs\n * nothing real and removes the question entirely.\n */\nconst IDENTIFIER = /^[a-z_][a-z0-9_]{0,62}$/;\n\n/** Whether this is a name the adapter will interpolate. */\nexport function isValidSchemaName(name: string): boolean {\n  // `pg_` is PostgreSQL's reserved prefix for system catalogs.\n  return IDENTIFIER.test(name) && !name.startsWith(\"pg_\");\n}\n\n/**\n * Return the name, or throw rather than interpolate something unchecked.\n *\n * The adapter throws a plain Error: it has no access to the config path that\n * produced the value, and `nextly` already refuses the same shapes at boot\n * with a message that names `db.postgres.schema`. This is the backstop for a\n * caller that constructed the adapter directly.\n */\nexport function assertSchemaName(name: string): string {\n  if (!isValidSchemaName(name)) {\n    throw new Error(\n      `Invalid PostgreSQL schema name \"${name}\". Use lower-case letters, digits and underscores, starting with a letter or underscore (max 63 characters), and not beginning with \"pg_\".`\n    );\n  }\n  return name;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAoBA,MAAM,aAAa;;AAGnB,SAAgB,kBAAkB,MAAuB;CAEvD,OAAO,WAAW,KAAK,IAAI,KAAK,CAAC,KAAK,WAAW,KAAK;AACxD;;;;;;;;;AAUA,SAAgB,iBAAiB,MAAsB;CACrD,IAAI,CAAC,kBAAkB,IAAI,GACzB,MAAM,IAAI,MACR,mCAAmC,KAAK,2IAC1C;CAEF,OAAO;AACT"}

package/dist/text-match.cjs

@@ -1,16 +1,50 @@
-'use strict';
-
-var drizzleOrm = require('drizzle-orm');
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let drizzle_orm = require("drizzle-orm");
 // src/text-match.ts
+/**
+* Case-insensitive, literal substring matching: the one rule for "does this text contain that,
+* ignoring case" on every dialect.
+*
+* The where builder's `ICONTAINS` compiles through it, and so does any caller that builds its own
+* SQL against a column, such as a collection's search, so the rule cannot be spelled two ways.
+*
+* @module text-match
+*/
+/**
+* Wraps a value in `%…%` for a substring match, escaping the LIKE metacharacters inside it so
+* the value matches literally.
+*
+* `!` is the escape character rather than the more usual backslash, and it has to be, because
+* this builder emits one statement for every dialect. SQLite gives LIKE no default escape
+* character at all, so a backslash there is just a backslash; declaring `ESCAPE '\'` instead
+* runs into MySQL, where the backslash also escapes inside the string literal and the clause
+* would have to be spelled differently per dialect. `ESCAPE '!'` parses identically on
+* PostgreSQL, MySQL and SQLite, and needs no per-dialect branch to stay correct.
+*
+* The escape character is escaped FIRST by including it in the character class, so a literal
+* `!` in the value cannot be produced by escaping something else afterwards.
+*/
 function containsPattern(value) {
-  return `%${value.replace(/[!%_]/g, (character) => `!${character}`)}%`;
+	return `%${value.replace(/[!%_]/g, (character) => `!${character}`)}%`;
 }
+/**
+* `column` contains `value`, without regard to case, on PostgreSQL, MySQL and SQLite, even where
+* the column's collation is case-sensitive: both sides lower-cased, `value` matched literally
+* (its `%` and `_` are characters to find, not wildcards).
+*
+* Which letters fold is the database's own `lower()` under the column's collation: MySQL by its
+* collation's Unicode version, PostgreSQL's non-ASCII letters too under a linguistic collation,
+* and ASCII letters only on SQLite and under PostgreSQL's `C` or `POSIX`.
+*
+* @experimental
+* @param column - The column, or any SQL expression yielding text
+* @param value - The text to find, as the person typed it
+* @returns The condition
+*/
 function caseInsensitiveContains(column, value) {
-  return drizzleOrm.sql`lower(${column}) like lower(${containsPattern(value)}) escape '!'`;
+	return drizzle_orm.sql`lower(${column}) like lower(${containsPattern(value)}) escape '!'`;
 }
-
 exports.caseInsensitiveContains = caseInsensitiveContains;
 exports.containsPattern = containsPattern;
-//# sourceMappingURL=text-match.cjs.map
+
 //# sourceMappingURL=text-match.cjs.map

package/dist/text-match.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/text-match.ts"],"names":["sql"],"mappings":";;;;;AAyBO,SAAS,gBAAgB,KAAA,EAAuB;AACrD,EAAA,OAAO,CAAA,CAAA,EAAI,MAAM,OAAA,CAAQ,QAAA,EAAU,eAAa,CAAA,CAAA,EAAI,SAAS,EAAE,CAAC,CAAA,CAAA,CAAA;AAClE;AAgBO,SAAS,uBAAA,CACd,QACA,KAAA,EACK;AACL,EAAA,OAAOA,cAAA,CAAA,MAAA,EAAY,MAAM,CAAA,aAAA,EAAgB,eAAA,CAAgB,KAAK,CAAC,CAAA,YAAA,CAAA;AACjE","file":"text-match.cjs","sourcesContent":["/**\n * Case-insensitive, literal substring matching: the one rule for \"does this text contain that,\n * ignoring case\" on every dialect.\n *\n * The where builder's `ICONTAINS` compiles through it, and so does any caller that builds its own\n * SQL against a column, such as a collection's search, so the rule cannot be spelled two ways.\n *\n * @module text-match\n */\nimport { sql, type SQL, type SQLWrapper } from \"drizzle-orm\";\n\n/**\n * Wraps a value in `%…%` for a substring match, escaping the LIKE metacharacters inside it so\n * the value matches literally.\n *\n * `!` is the escape character rather than the more usual backslash, and it has to be, because\n * this builder emits one statement for every dialect. SQLite gives LIKE no default escape\n * character at all, so a backslash there is just a backslash; declaring `ESCAPE '\\'` instead\n * runs into MySQL, where the backslash also escapes inside the string literal and the clause\n * would have to be spelled differently per dialect. `ESCAPE '!'` parses identically on\n * PostgreSQL, MySQL and SQLite, and needs no per-dialect branch to stay correct.\n *\n * The escape character is escaped FIRST by including it in the character class, so a literal\n * `!` in the value cannot be produced by escaping something else afterwards.\n */\nexport function containsPattern(value: string): string {\n  return `%${value.replace(/[!%_]/g, character => `!${character}`)}%`;\n}\n\n/**\n * `column` contains `value`, without regard to case, on PostgreSQL, MySQL and SQLite, even where\n * the column's collation is case-sensitive: both sides lower-cased, `value` matched literally\n * (its `%` and `_` are characters to find, not wildcards).\n *\n * Which letters fold is the database's own `lower()` under the column's collation: MySQL by its\n * collation's Unicode version, PostgreSQL's non-ASCII letters too under a linguistic collation,\n * and ASCII letters only on SQLite and under PostgreSQL's `C` or `POSIX`.\n *\n * @experimental\n * @param column - The column, or any SQL expression yielding text\n * @param value - The text to find, as the person typed it\n * @returns The condition\n */\nexport function caseInsensitiveContains(\n  column: SQLWrapper,\n  value: string\n): SQL {\n  return sql`lower(${column}) like lower(${containsPattern(value)}) escape '!'`;\n}\n"]}
+{"version":3,"file":"text-match.cjs","names":[],"sources":["../src/text-match.ts"],"sourcesContent":["/**\n * Case-insensitive, literal substring matching: the one rule for \"does this text contain that,\n * ignoring case\" on every dialect.\n *\n * The where builder's `ICONTAINS` compiles through it, and so does any caller that builds its own\n * SQL against a column, such as a collection's search, so the rule cannot be spelled two ways.\n *\n * @module text-match\n */\nimport { sql, type SQL, type SQLWrapper } from \"drizzle-orm\";\n\n/**\n * Wraps a value in `%…%` for a substring match, escaping the LIKE metacharacters inside it so\n * the value matches literally.\n *\n * `!` is the escape character rather than the more usual backslash, and it has to be, because\n * this builder emits one statement for every dialect. SQLite gives LIKE no default escape\n * character at all, so a backslash there is just a backslash; declaring `ESCAPE '\\'` instead\n * runs into MySQL, where the backslash also escapes inside the string literal and the clause\n * would have to be spelled differently per dialect. `ESCAPE '!'` parses identically on\n * PostgreSQL, MySQL and SQLite, and needs no per-dialect branch to stay correct.\n *\n * The escape character is escaped FIRST by including it in the character class, so a literal\n * `!` in the value cannot be produced by escaping something else afterwards.\n */\nexport function containsPattern(value: string): string {\n  return `%${value.replace(/[!%_]/g, character => `!${character}`)}%`;\n}\n\n/**\n * `column` contains `value`, without regard to case, on PostgreSQL, MySQL and SQLite, even where\n * the column's collation is case-sensitive: both sides lower-cased, `value` matched literally\n * (its `%` and `_` are characters to find, not wildcards).\n *\n * Which letters fold is the database's own `lower()` under the column's collation: MySQL by its\n * collation's Unicode version, PostgreSQL's non-ASCII letters too under a linguistic collation,\n * and ASCII letters only on SQLite and under PostgreSQL's `C` or `POSIX`.\n *\n * @experimental\n * @param column - The column, or any SQL expression yielding text\n * @param value - The text to find, as the person typed it\n * @returns The condition\n */\nexport function caseInsensitiveContains(\n  column: SQLWrapper,\n  value: string\n): SQL {\n  return sql`lower(${column}) like lower(${containsPattern(value)}) escape '!'`;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAgB,gBAAgB,OAAuB;CACrD,OAAO,IAAI,MAAM,QAAQ,WAAU,cAAa,IAAI,WAAW,EAAE;AACnE;;;;;;;;;;;;;;;AAgBA,SAAgB,wBACd,QACA,OACK;CACL,OAAO,YAAA,GAAG,SAAS,OAAO,eAAe,gBAAgB,KAAK,EAAE;AAClE"}

package/dist/text-match.d.cts

@@ -1,15 +1,4 @@
-import { SQLWrapper, SQL } from 'drizzle-orm';
-
-/**
- * Case-insensitive, literal substring matching: the one rule for "does this text contain that,
- * ignoring case" on every dialect.
- *
- * The where builder's `ICONTAINS` compiles through it, and so does any caller that builds its own
- * SQL against a column, such as a collection's search, so the rule cannot be spelled two ways.
- *
- * @module text-match
- */
-
+import { SQL, SQLWrapper } from "drizzle-orm";
 /**
  * Wraps a value in `%…%` for a substring match, escaping the LIKE metacharacters inside it so
  * the value matches literally.
@@ -24,7 +13,7 @@ import { SQLWrapper, SQL } from 'drizzle-orm';
  * The escape character is escaped FIRST by including it in the character class, so a literal
  * `!` in the value cannot be produced by escaping something else afterwards.
  */
-declare function containsPattern(value: string): string;
+export declare function containsPattern(value: string): string;
 /**
  * `column` contains `value`, without regard to case, on PostgreSQL, MySQL and SQLite, even where
  * the column's collation is case-sensitive: both sides lower-cased, `value` matched literally
@@ -39,6 +28,5 @@ declare function containsPattern(value: string): string;
  * @param value - The text to find, as the person typed it
  * @returns The condition
  */
-declare function caseInsensitiveContains(column: SQLWrapper, value: string): SQL;
-
-export { caseInsensitiveContains, containsPattern };
+export declare function caseInsensitiveContains(column: SQLWrapper, value: string): SQL;
+//# sourceMappingURL=text-match.d.cts.map

package/dist/text-match.d.ts

@@ -1,15 +1,4 @@
-import { SQLWrapper, SQL } from 'drizzle-orm';
-
-/**
- * Case-insensitive, literal substring matching: the one rule for "does this text contain that,
- * ignoring case" on every dialect.
- *
- * The where builder's `ICONTAINS` compiles through it, and so does any caller that builds its own
- * SQL against a column, such as a collection's search, so the rule cannot be spelled two ways.
- *
- * @module text-match
- */
-
+import { SQL, SQLWrapper } from "drizzle-orm";
 /**
  * Wraps a value in `%…%` for a substring match, escaping the LIKE metacharacters inside it so
  * the value matches literally.
@@ -24,7 +13,7 @@ import { SQLWrapper, SQL } from 'drizzle-orm';
  * The escape character is escaped FIRST by including it in the character class, so a literal
  * `!` in the value cannot be produced by escaping something else afterwards.
  */
-declare function containsPattern(value: string): string;
+export declare function containsPattern(value: string): string;
 /**
  * `column` contains `value`, without regard to case, on PostgreSQL, MySQL and SQLite, even where
  * the column's collation is case-sensitive: both sides lower-cased, `value` matched literally
@@ -39,6 +28,5 @@ declare function containsPattern(value: string): string;
  * @param value - The text to find, as the person typed it
  * @returns The condition
  */
-declare function caseInsensitiveContains(column: SQLWrapper, value: string): SQL;
-
-export { caseInsensitiveContains, containsPattern };
+export declare function caseInsensitiveContains(column: SQLWrapper, value: string): SQL;
+//# sourceMappingURL=text-match.d.ts.map

package/dist/text-match.mjs

@@ -1,13 +1,48 @@
-import { sql } from 'drizzle-orm';
-
+import { sql } from "drizzle-orm";
 // src/text-match.ts
+/**
+* Case-insensitive, literal substring matching: the one rule for "does this text contain that,
+* ignoring case" on every dialect.
+*
+* The where builder's `ICONTAINS` compiles through it, and so does any caller that builds its own
+* SQL against a column, such as a collection's search, so the rule cannot be spelled two ways.
+*
+* @module text-match
+*/
+/**
+* Wraps a value in `%…%` for a substring match, escaping the LIKE metacharacters inside it so
+* the value matches literally.
+*
+* `!` is the escape character rather than the more usual backslash, and it has to be, because
+* this builder emits one statement for every dialect. SQLite gives LIKE no default escape
+* character at all, so a backslash there is just a backslash; declaring `ESCAPE '\'` instead
+* runs into MySQL, where the backslash also escapes inside the string literal and the clause
+* would have to be spelled differently per dialect. `ESCAPE '!'` parses identically on
+* PostgreSQL, MySQL and SQLite, and needs no per-dialect branch to stay correct.
+*
+* The escape character is escaped FIRST by including it in the character class, so a literal
+* `!` in the value cannot be produced by escaping something else afterwards.
+*/
 function containsPattern(value) {
-  return `%${value.replace(/[!%_]/g, (character) => `!${character}`)}%`;
+	return `%${value.replace(/[!%_]/g, (character) => `!${character}`)}%`;
 }
+/**
+* `column` contains `value`, without regard to case, on PostgreSQL, MySQL and SQLite, even where
+* the column's collation is case-sensitive: both sides lower-cased, `value` matched literally
+* (its `%` and `_` are characters to find, not wildcards).
+*
+* Which letters fold is the database's own `lower()` under the column's collation: MySQL by its
+* collation's Unicode version, PostgreSQL's non-ASCII letters too under a linguistic collation,
+* and ASCII letters only on SQLite and under PostgreSQL's `C` or `POSIX`.
+*
+* @experimental
+* @param column - The column, or any SQL expression yielding text
+* @param value - The text to find, as the person typed it
+* @returns The condition
+*/
 function caseInsensitiveContains(column, value) {
-  return sql`lower(${column}) like lower(${containsPattern(value)}) escape '!'`;
+	return sql`lower(${column}) like lower(${containsPattern(value)}) escape '!'`;
 }
-
 export { caseInsensitiveContains, containsPattern };
-//# sourceMappingURL=text-match.mjs.map
+
 //# sourceMappingURL=text-match.mjs.map

package/dist/text-match.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/text-match.ts"],"names":[],"mappings":";;;AAyBO,SAAS,gBAAgB,KAAA,EAAuB;AACrD,EAAA,OAAO,CAAA,CAAA,EAAI,MAAM,OAAA,CAAQ,QAAA,EAAU,eAAa,CAAA,CAAA,EAAI,SAAS,EAAE,CAAC,CAAA,CAAA,CAAA;AAClE;AAgBO,SAAS,uBAAA,CACd,QACA,KAAA,EACK;AACL,EAAA,OAAO,GAAA,CAAA,MAAA,EAAY,MAAM,CAAA,aAAA,EAAgB,eAAA,CAAgB,KAAK,CAAC,CAAA,YAAA,CAAA;AACjE","file":"text-match.mjs","sourcesContent":["/**\n * Case-insensitive, literal substring matching: the one rule for \"does this text contain that,\n * ignoring case\" on every dialect.\n *\n * The where builder's `ICONTAINS` compiles through it, and so does any caller that builds its own\n * SQL against a column, such as a collection's search, so the rule cannot be spelled two ways.\n *\n * @module text-match\n */\nimport { sql, type SQL, type SQLWrapper } from \"drizzle-orm\";\n\n/**\n * Wraps a value in `%…%` for a substring match, escaping the LIKE metacharacters inside it so\n * the value matches literally.\n *\n * `!` is the escape character rather than the more usual backslash, and it has to be, because\n * this builder emits one statement for every dialect. SQLite gives LIKE no default escape\n * character at all, so a backslash there is just a backslash; declaring `ESCAPE '\\'` instead\n * runs into MySQL, where the backslash also escapes inside the string literal and the clause\n * would have to be spelled differently per dialect. `ESCAPE '!'` parses identically on\n * PostgreSQL, MySQL and SQLite, and needs no per-dialect branch to stay correct.\n *\n * The escape character is escaped FIRST by including it in the character class, so a literal\n * `!` in the value cannot be produced by escaping something else afterwards.\n */\nexport function containsPattern(value: string): string {\n  return `%${value.replace(/[!%_]/g, character => `!${character}`)}%`;\n}\n\n/**\n * `column` contains `value`, without regard to case, on PostgreSQL, MySQL and SQLite, even where\n * the column's collation is case-sensitive: both sides lower-cased, `value` matched literally\n * (its `%` and `_` are characters to find, not wildcards).\n *\n * Which letters fold is the database's own `lower()` under the column's collation: MySQL by its\n * collation's Unicode version, PostgreSQL's non-ASCII letters too under a linguistic collation,\n * and ASCII letters only on SQLite and under PostgreSQL's `C` or `POSIX`.\n *\n * @experimental\n * @param column - The column, or any SQL expression yielding text\n * @param value - The text to find, as the person typed it\n * @returns The condition\n */\nexport function caseInsensitiveContains(\n  column: SQLWrapper,\n  value: string\n): SQL {\n  return sql`lower(${column}) like lower(${containsPattern(value)}) escape '!'`;\n}\n"]}
+{"version":3,"file":"text-match.mjs","names":[],"sources":["../src/text-match.ts"],"sourcesContent":["/**\n * Case-insensitive, literal substring matching: the one rule for \"does this text contain that,\n * ignoring case\" on every dialect.\n *\n * The where builder's `ICONTAINS` compiles through it, and so does any caller that builds its own\n * SQL against a column, such as a collection's search, so the rule cannot be spelled two ways.\n *\n * @module text-match\n */\nimport { sql, type SQL, type SQLWrapper } from \"drizzle-orm\";\n\n/**\n * Wraps a value in `%…%` for a substring match, escaping the LIKE metacharacters inside it so\n * the value matches literally.\n *\n * `!` is the escape character rather than the more usual backslash, and it has to be, because\n * this builder emits one statement for every dialect. SQLite gives LIKE no default escape\n * character at all, so a backslash there is just a backslash; declaring `ESCAPE '\\'` instead\n * runs into MySQL, where the backslash also escapes inside the string literal and the clause\n * would have to be spelled differently per dialect. `ESCAPE '!'` parses identically on\n * PostgreSQL, MySQL and SQLite, and needs no per-dialect branch to stay correct.\n *\n * The escape character is escaped FIRST by including it in the character class, so a literal\n * `!` in the value cannot be produced by escaping something else afterwards.\n */\nexport function containsPattern(value: string): string {\n  return `%${value.replace(/[!%_]/g, character => `!${character}`)}%`;\n}\n\n/**\n * `column` contains `value`, without regard to case, on PostgreSQL, MySQL and SQLite, even where\n * the column's collation is case-sensitive: both sides lower-cased, `value` matched literally\n * (its `%` and `_` are characters to find, not wildcards).\n *\n * Which letters fold is the database's own `lower()` under the column's collation: MySQL by its\n * collation's Unicode version, PostgreSQL's non-ASCII letters too under a linguistic collation,\n * and ASCII letters only on SQLite and under PostgreSQL's `C` or `POSIX`.\n *\n * @experimental\n * @param column - The column, or any SQL expression yielding text\n * @param value - The text to find, as the person typed it\n * @returns The condition\n */\nexport function caseInsensitiveContains(\n  column: SQLWrapper,\n  value: string\n): SQL {\n  return sql`lower(${column}) like lower(${containsPattern(value)}) escape '!'`;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAgB,gBAAgB,OAAuB;CACrD,OAAO,IAAI,MAAM,QAAQ,WAAU,cAAa,IAAI,WAAW,EAAE;AACnE;;;;;;;;;;;;;;;AAgBA,SAAgB,wBACd,QACA,OACK;CACL,OAAO,GAAG,SAAS,OAAO,eAAe,gBAAgB,KAAK,EAAE;AAClE"}