@elaraai/east-node-io 0.0.1-beta.9 → 1.0.0

package/dist/src/sql/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/sql/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;GAOG;AAGH,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAgD3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,GAAG;IACZ;;;;OAIG;;QAEC;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA4BG;;;;;;QAGH;;;;;;;;;;;;;;;;;;;;;;;;;;WA0BG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAGH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAuCG;;;;;;;;;;QAGH;;;;;;;;;;;;;;;;;;;;;;WAsBG;;QAGH;;;;;;;;;;;;;;;;;;;;;WAqBG;;QAGH;;;;WAIG;;QAGH;;WAEG;;YAEC;;eAEG;;;;;;YAGH;;eAEG;;;;;;;;;;YAGH;;eAEG;;;;;;;;;;YAGH;;eAEG;;;;;;;;;;YAGH;;eAEG;;;;;;;;;;;;;;;;;;;;;;;;;;IAKX;;;;OAIG;;QAEC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAgCG;;;;;;;;;;QAGH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA8BG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAGH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAuCG;;;;;;;;;;QAGH;;;;;;;;;;;;;;;;;;;;;;;;;;WA0BG;;QAGH;;;;;;;;;;;;;;;;;;;;;WAqBG;;QAGH;;;;WAIG;;QAGH;;WAEG;;YAEC;;eAEG;;;;;;;;;;YAGH;;eAEG;;;;;;;;;;YAGH;;eAEG;;;;;;;;;;YAGH;;eAEG;;;;;;;;;;YAGH;;eAEG;;;;;;;;;;;;;;;;;;;;;;;;;;IAKX;;;;OAIG;;QAEC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAgCG;;;;;;;;;;QAGH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA8BG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAGH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAuCG;;;;;;;;;;QAGH;;;;;;;;;;;;;;;;;;;;;;;;;;WA0BG;;QAGH;;;;;;;;;;;;;;;;;;;;;WAqBG;;QAGH;;;;WAIG;;QAGH;;WAEG;;YAEC;;eAEG;;;;;;;;;;YAGH;;eAEG;;;;;;;;;;YAGH;;eAEG;;;;;;;;;;YAGH;;eAEG;;;;;;;;;;YAGH;;eAEG;;;;;;;;;;;;;;;;;;;;;;;;;;IAKX;;;;;OAKG;;QAEC;;;;;;;;;;;;;;;;;;;;;;WAsBG;;;;;QAGH;;;;;;;;;;;;;;;;;;;;;;;WAuBG;;;;QAGH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAuCG;;;;;;;QAGH;;;;;;;;;;;;;;;;;;;;;WAqBG;;QAGH;;;;;;;;;;;;;;;;;;;;;WAqBG;;QAGH;;;;WAIG;;QAGH;;WAEG;;YAEC;;eAEG;;;;;YAGH;;eAEG;;;;;;;YAGH;;eAEG;;;;;;CAIL,CAAC"}

package/dist/{sql → src/sql}/index.js

@@ -14,12 +14,14 @@
 export * from "./sqlite.js";
 export * from "./postgres.js";
 export * from "./mysql.js";
+export * from "./access.js";
 export * from "./types.js";
 // Import for grouped exports
-import { sqlite_connect, sqlite_query, sqlite_close, sqlite_close_all, SqliteImpl } from "./sqlite.js";
-import { postgres_connect, postgres_query, postgres_close, postgres_close_all, PostgresImpl } from "./postgres.js";
-import { mysql_connect, mysql_query, mysql_close, mysql_close_all, MySqlImpl } from "./mysql.js";
-import { SqliteConfigType, PostgresConfigType, MySqlConfigType, SqlParameterType, SqlParametersType, SqlRowType, SqlResultType } from "./types.js";
+import { sqlite_connect, sqlite_query, sqlite_select, sqlite_close, sqlite_close_all, SqliteImpl } from "./sqlite.js";
+import { postgres_connect, postgres_query, postgres_select, postgres_close, postgres_close_all, PostgresImpl } from "./postgres.js";
+import { mysql_connect, mysql_query, mysql_select, mysql_close, mysql_close_all, MySqlImpl } from "./mysql.js";
+import { access_open, access_tables, access_query, access_close, access_close_all, AccessImpl } from "./access.js";
+import { SqliteConfigType, PostgresConfigType, MySqlConfigType, AccessConfigType, AccessQueryOptionsType, AccessTablesResultType, SqlParameterType, SqlParametersType, SqlRowType, SqlResultType } from "./types.js";
 /**
  * SQL database platform functions.
  *
@@ -122,6 +124,47 @@ export const SQL = {
          * ```
          */
         query: sqlite_query,
+        /**
+         * Executes a SELECT query with user-defined return type.
+         *
+         * Runs a SELECT query and returns typed rows. The return type is generic,
+         * allowing users to specify the expected row structure for type-safe access.
+         *
+         * @example
+         * ```ts
+         * const UserRowType = StructType({
+         *     id: IntegerType,
+         *     name: StringType,
+         * });
+         *
+         * const getUsers = East.function([], NullType, ($) => {
+         *     const config = $.let({
+         *         path: ":memory:",
+         *         readOnly: variant('none', null),
+         *         memory: variant('some', true),
+         *     });
+         *     const conn = $.let(SQL.SQLite.connect(config));
+         *
+         *     // Create table and insert data
+         *     $(SQL.SQLite.query(conn, "CREATE TABLE users (id INTEGER, name TEXT)", []));
+         *     $(SQL.SQLite.query(conn, "INSERT INTO users VALUES (1, 'Alice')", []));
+         *
+         *     // Query with typed results
+         *     const users = $.let(SQL.SQLite.select([UserRowType], conn,
+         *         "SELECT id, name FROM users",
+         *         []
+         *     ));
+         *     // users is typed as Array<{ id: bigint, name: string }>
+         *
+         *     $(SQL.SQLite.close(conn));
+         *     $.return(null);
+         * });
+         *
+         * const compiled = East.compileAsync(getUsers.toIR(), SQL.SQLite.Implementation);
+         * await compiled();
+         * ```
+         */
+        select: sqlite_select,
         /**
          * Closes the SQLite database connection.
          *
@@ -273,6 +316,47 @@ export const SQL = {
          * ```
          */
         query: postgres_query,
+        /**
+         * Executes a SELECT query with user-defined return type.
+         *
+         * Runs a SELECT query and returns typed rows. The return type is generic,
+         * allowing users to specify the expected row structure for type-safe access.
+         *
+         * @example
+         * ```ts
+         * const UserRowType = StructType({
+         *     id: IntegerType,
+         *     name: StringType,
+         * });
+         *
+         * const getUsers = East.function([], NullType, ($) => {
+         *     const config = $.let({
+         *         host: "localhost",
+         *         port: 5432n,
+         *         database: "myapp",
+         *         user: "postgres",
+         *         password: "secret",
+         *         ssl: variant('none', null),
+         *         maxConnections: variant('none', null),
+         *     });
+         *     const conn = $.let(SQL.Postgres.connect(config));
+         *
+         *     // Query with typed results
+         *     const users = $.let(SQL.Postgres.select([UserRowType], conn,
+         *         "SELECT id, name FROM users",
+         *         []
+         *     ));
+         *     // users is typed as Array<{ id: bigint, name: string }>
+         *
+         *     $(SQL.Postgres.close(conn));
+         *     $.return(null);
+         * });
+         *
+         * const compiled = East.compileAsync(getUsers.toIR(), SQL.Postgres.Implementation);
+         * await compiled();
+         * ```
+         */
+        select: postgres_select,
         /**
          * Closes the PostgreSQL connection pool.
          *
@@ -428,6 +512,47 @@ export const SQL = {
          * ```
          */
         query: mysql_query,
+        /**
+         * Executes a SELECT query with user-defined return type.
+         *
+         * Runs a SELECT query and returns typed rows. The return type is generic,
+         * allowing users to specify the expected row structure for type-safe access.
+         *
+         * @example
+         * ```ts
+         * const UserRowType = StructType({
+         *     id: IntegerType,
+         *     name: StringType,
+         * });
+         *
+         * const getUsers = East.function([], NullType, ($) => {
+         *     const config = $.let({
+         *         host: "localhost",
+         *         port: 3306n,
+         *         database: "myapp",
+         *         user: "root",
+         *         password: "secret",
+         *         ssl: variant('none', null),
+         *         maxConnections: variant('none', null),
+         *     });
+         *     const conn = $.let(SQL.MySQL.connect(config));
+         *
+         *     // Query with typed results
+         *     const users = $.let(SQL.MySQL.select([UserRowType], conn,
+         *         "SELECT id, name FROM users",
+         *         []
+         *     ));
+         *     // users is typed as Array<{ id: bigint, name: string }>
+         *
+         *     $(SQL.MySQL.close(conn));
+         *     $.return(null);
+         * });
+         *
+         * const compiled = East.compileAsync(getUsers.toIR(), SQL.MySQL.Implementation);
+         * await compiled();
+         * ```
+         */
+        select: mysql_select,
         /**
          * Closes the MySQL connection pool.
          *
@@ -511,5 +636,172 @@ export const SQL = {
             Result: SqlResultType,
         },
     },
+    /**
+     * Microsoft Access database operations.
+     *
+     * Provides read-only platform functions for Access databases (.mdb, .accdb).
+     * Supports Access 97 through Access 2019, including encrypted databases.
+     */
+    Access: {
+        /**
+         * Opens a Microsoft Access database file.
+         *
+         * Opens an Access database file and returns an opaque handle for use in queries.
+         *
+         * @example
+         * ```ts
+         * const listTables = East.function([], NullType, ($) => {
+         *     const config = $.let({
+         *         path: "./database.mdb",
+         *         password: variant('none', null),
+         *     });
+         *
+         *     const conn = $.let(SQL.Access.open(config));
+         *     const tables = $.let(SQL.Access.tables(conn));
+         *     $(SQL.Access.close(conn));
+         *     $.return(null);
+         * });
+         *
+         * const compiled = East.compileAsync(listTables.toIR(), SQL.Access.Implementation);
+         * await compiled();
+         * ```
+         */
+        open: access_open,
+        /**
+         * Lists all table names in an Access database.
+         *
+         * Returns an array of normal table names (not system or linked tables).
+         *
+         * @example
+         * ```ts
+         * const showTables = East.function([], NullType, ($) => {
+         *     const config = $.let({
+         *         path: "./database.mdb",
+         *         password: variant('none', null),
+         *     });
+         *
+         *     const conn = $.let(SQL.Access.open(config));
+         *     const result = $.let(SQL.Access.tables(conn));
+         *     // result.tables contains ['Table1', 'Table2', ...]
+         *     $(SQL.Access.close(conn));
+         *     $.return(null);
+         * });
+         *
+         * const compiled = East.compileAsync(showTables.toIR(), SQL.Access.Implementation);
+         * await compiled();
+         * ```
+         */
+        tables: access_tables,
+        /**
+         * Queries data from an Access database table with a user-defined return type.
+         *
+         * Reads rows from a specified table with optional column selection and pagination.
+         * The return type is generic, allowing users to specify the expected row structure.
+         *
+         * @typeParam T - The expected row type for query results
+         *
+         * @example
+         * ```ts
+         * // Define the expected row type
+         * const UserRowType = StructType({
+         *     id: IntegerType,
+         *     name: StringType,
+         *     email: StringType,
+         * });
+         *
+         * const queryUsers = East.function([], NullType, ($) => {
+         *     const config = $.let({
+         *         path: "./database.mdb",
+         *         password: variant('none', null),
+         *     });
+         *
+         *     const conn = $.let(SQL.Access.open(config));
+         *     // Query with typed results - returns Array<UserRowType>
+         *     const users = $.let(SQL.Access.query([UserRowType], conn, {
+         *         table: "Users",
+         *         columns: variant('some', ["id", "name", "email"]),
+         *         rowOffset: variant('none', null),
+         *         rowLimit: variant('some', 100n),
+         *     }));
+         *     // users is typed as Array<{ id: bigint, name: string, email: string }>
+         *     $(SQL.Access.close(conn));
+         *     $.return(null);
+         * });
+         *
+         * const compiled = East.compileAsync(queryUsers.toIR(), SQL.Access.Implementation);
+         * await compiled();
+         * ```
+         */
+        query: access_query,
+        /**
+         * Closes an Access database connection.
+         *
+         * Releases all resources associated with the connection.
+         *
+         * @example
+         * ```ts
+         * const cleanup = East.function([], NullType, $ => {
+         *     const config = $.let({
+         *         path: "./database.mdb",
+         *         password: variant('none', null),
+         *     });
+         *     const conn = $.let(SQL.Access.open(config));
+         *     // ... do work ...
+         *     $(SQL.Access.close(conn));
+         *     $.return(null);
+         * });
+         *
+         * const compiled = East.compileAsync(cleanup.toIR(), SQL.Access.Implementation);
+         * await compiled();
+         * ```
+         */
+        close: access_close,
+        /**
+         * Closes all Access database connections.
+         *
+         * Closes all active Access connections and releases all resources.
+         * Useful for test cleanup to ensure all connections are closed.
+         *
+         * @returns Null on success
+         *
+         * @example
+         * ```ts
+         * const cleanupAll = East.function([], NullType, $ => {
+         *     // ... test code that may have left connections open ...
+         *     $(SQL.Access.closeAll());
+         *     return $.return(null);
+         * });
+         *
+         * const compiled = East.compileAsync(cleanupAll.toIR(), SQL.Access.Implementation);
+         * await compiled();
+         * ```
+         *
+         * @internal
+         */
+        closeAll: access_close_all,
+        /**
+         * Node.js implementation of Access platform functions.
+         *
+         * Pass this to East.compileAsync() to enable Access operations.
+         */
+        Implementation: AccessImpl,
+        /**
+         * Type definitions for Access operations.
+         */
+        Types: {
+            /**
+             * Access connection configuration type.
+             */
+            Config: AccessConfigType,
+            /**
+             * Access query options type.
+             */
+            QueryOptions: AccessQueryOptionsType,
+            /**
+             * Access tables list result type.
+             */
+            TablesResult: AccessTablesResultType,
+        },
+    },
 };
 //# sourceMappingURL=index.js.map

package/dist/src/sql/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/sql/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;GAOG;AAEH,4BAA4B;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAE3B,6BAA6B;AAC7B,OAAO,EACH,cAAc,EACd,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,gBAAgB,EAChB,UAAU,EACb,MAAM,aAAa,CAAC;AACrB,OAAO,EACH,gBAAgB,EAChB,cAAc,EACd,eAAe,EACf,cAAc,EACd,kBAAkB,EAClB,YAAY,EACf,MAAM,eAAe,CAAC;AACvB,OAAO,EACH,aAAa,EACb,WAAW,EACX,YAAY,EACZ,WAAW,EACX,eAAe,EACf,SAAS,EACZ,MAAM,YAAY,CAAC;AACpB,OAAO,EACH,WAAW,EACX,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,gBAAgB,EAChB,UAAU,EACb,MAAM,aAAa,CAAC;AACrB,OAAO,EACH,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EACf,gBAAgB,EAChB,sBAAsB,EACtB,sBAAsB,EACtB,gBAAgB,EAChB,iBAAiB,EACjB,UAAU,EACV,aAAa,EAChB,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAM,CAAC,MAAM,GAAG,GAAG;IACf;;;;OAIG;IACH,MAAM,EAAE;QACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA4BG;QACH,OAAO,EAAE,cAAc;QAEvB;;;;;;;;;;;;;;;;;;;;;;;;;;WA0BG;QACH,KAAK,EAAE,YAAY;QAEnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAuCG;QACH,MAAM,EAAE,aAAa;QAErB;;;;;;;;;;;;;;;;;;;;;;WAsBG;QACH,KAAK,EAAE,YAAY;QAEnB;;;;;;;;;;;;;;;;;;;;;WAqBG;QACH,QAAQ,EAAE,gBAAgB;QAE1B;;;;WAIG;QACH,cAAc,EAAE,UAAU;QAE1B;;WAEG;QACH,KAAK,EAAE;YACH;;eAEG;YACH,MAAM,EAAE,gBAAgB;YAExB;;eAEG;YACH,SAAS,EAAE,gBAAgB;YAE3B;;eAEG;YACH,UAAU,EAAE,iBAAiB;YAE7B;;eAEG;YACH,GAAG,EAAE,UAAU;YAEf;;eAEG;YACH,MAAM,EAAE,aAAa;SACxB;KACJ;IAED;;;;OAIG;IACH,QAAQ,EAAE;QACN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAgCG;QACH,OAAO,EAAE,gBAAgB;QAEzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA8BG;QACH,KAAK,EAAE,cAAc;QAErB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAuCG;QACH,MAAM,EAAE,eAAe;QAEvB;;;;;;;;;;;;;;;;;;;;;;;;;;WA0BG;QACH,KAAK,EAAE,cAAc;QAErB;;;;;;;;;;;;;;;;;;;;;WAqBG;QACH,QAAQ,EAAE,kBAAkB;QAE5B;;;;WAIG;QACH,cAAc,EAAE,YAAY;QAE5B;;WAEG;QACH,KAAK,EAAE;YACH;;eAEG;YACH,MAAM,EAAE,kBAAkB;YAE1B;;eAEG;YACH,SAAS,EAAE,gBAAgB;YAE3B;;eAEG;YACH,UAAU,EAAE,iBAAiB;YAE7B;;eAEG;YACH,GAAG,EAAE,UAAU;YAEf;;eAEG;YACH,MAAM,EAAE,aAAa;SACxB;KACJ;IAED;;;;OAIG;IACH,KAAK,EAAE;QACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAgCG;QACH,OAAO,EAAE,aAAa;QAEtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA8BG;QACH,KAAK,EAAE,WAAW;QAElB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAuCG;QACH,MAAM,EAAE,YAAY;QAEpB;;;;;;;;;;;;;;;;;;;;;;;;;;WA0BG;QACH,KAAK,EAAE,WAAW;QAElB;;;;;;;;;;;;;;;;;;;;;WAqBG;QACH,QAAQ,EAAE,eAAe;QAEzB;;;;WAIG;QACH,cAAc,EAAE,SAAS;QAEzB;;WAEG;QACH,KAAK,EAAE;YACH;;eAEG;YACH,MAAM,EAAE,eAAe;YAEvB;;eAEG;YACH,SAAS,EAAE,gBAAgB;YAE3B;;eAEG;YACH,UAAU,EAAE,iBAAiB;YAE7B;;eAEG;YACH,GAAG,EAAE,UAAU;YAEf;;eAEG;YACH,MAAM,EAAE,aAAa;SACxB;KACJ;IAED;;;;;OAKG;IACH,MAAM,EAAE;QACJ;;;;;;;;;;;;;;;;;;;;;;WAsBG;QACH,IAAI,EAAE,WAAW;QAEjB;;;;;;;;;;;;;;;;;;;;;;;WAuBG;QACH,MAAM,EAAE,aAAa;QAErB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAuCG;QACH,KAAK,EAAE,YAAY;QAEnB;;;;;;;;;;;;;;;;;;;;;WAqBG;QACH,KAAK,EAAE,YAAY;QAEnB;;;;;;;;;;;;;;;;;;;;;WAqBG;QACH,QAAQ,EAAE,gBAAgB;QAE1B;;;;WAIG;QACH,cAAc,EAAE,UAAU;QAE1B;;WAEG;QACH,KAAK,EAAE;YACH;;eAEG;YACH,MAAM,EAAE,gBAAgB;YAExB;;eAEG;YACH,YAAY,EAAE,sBAAsB;YAEpC;;eAEG;YACH,YAAY,EAAE,sBAAsB;SACvC;KACJ;CACK,CAAC"}

package/dist/{sql → src/sql}/mysql.d.ts

@@ -10,7 +10,7 @@
  *
  * @packageDocumentation
  */
-import { BlobType, BooleanType, DateTimeType, FloatType, IntegerType, NullType, StringType as EastStringType } from "@elaraai/east";
+import { ArrayType, BlobType, BooleanType, DateTimeType, FloatType, IntegerType, NullType, OptionType, StringType as EastStringType } from "@elaraai/east";
 import type { PlatformFunction } from "@elaraai/east/internal";
 import { StringType } from './types.js';
 /**
@@ -69,13 +69,13 @@ import { StringType } from './types.js';
  * - Connections are automatically returned to the pool after queries
  */
 export declare const mysql_connect: import("@elaraai/east").AsyncPlatformDefinition<[import("@elaraai/east").StructType<{
-    host: EastStringType;
-    port: IntegerType;
-    database: EastStringType;
-    user: EastStringType;
-    password: EastStringType;
-    ssl: import("@elaraai/east").OptionType<BooleanType>;
-    maxConnections: import("@elaraai/east").OptionType<IntegerType>;
+    readonly host: EastStringType;
+    readonly port: IntegerType;
+    readonly database: EastStringType;
+    readonly user: EastStringType;
+    readonly password: EastStringType;
+    readonly ssl: OptionType<BooleanType>;
+    readonly maxConnections: OptionType<IntegerType>;
 }>], EastStringType>;
 /**
  * Executes a SQL query with parameterized values.
@@ -135,37 +135,115 @@ export declare const mysql_connect: import("@elaraai/east").AsyncPlatformDefinit
  * - Parameters prevent SQL injection attacks
  * - Returns lastInsertId for INSERT operations
  */
-export declare const mysql_query: import("@elaraai/east").AsyncPlatformDefinition<[EastStringType, EastStringType, import("@elaraai/east").ArrayType<import("@elaraai/east").VariantType<{
-    Null: NullType;
-    Boolean: BooleanType;
-    Integer: IntegerType;
-    Float: FloatType;
-    String: StringType;
-    DateTime: DateTimeType;
-    Blob: BlobType;
+export declare const mysql_query: import("@elaraai/east").AsyncPlatformDefinition<[EastStringType, EastStringType, ArrayType<import("@elaraai/east").VariantType<{
+    readonly Null: NullType;
+    readonly Boolean: BooleanType;
+    readonly Integer: IntegerType;
+    readonly Float: FloatType;
+    readonly String: StringType;
+    readonly DateTime: DateTimeType;
+    readonly Blob: BlobType;
 }>>], import("@elaraai/east").VariantType<{
-    select: import("@elaraai/east").StructType<{
-        rows: import("@elaraai/east").ArrayType<import("@elaraai/east").DictType<EastStringType, import("@elaraai/east").VariantType<{
-            Null: NullType;
-            Boolean: BooleanType;
-            Integer: IntegerType;
-            Float: FloatType;
-            String: StringType;
-            DateTime: DateTimeType;
-            Blob: BlobType;
+    readonly select: import("@elaraai/east").StructType<{
+        readonly rows: ArrayType<import("@elaraai/east").DictType<EastStringType, import("@elaraai/east").VariantType<{
+            readonly Null: NullType;
+            readonly Boolean: BooleanType;
+            readonly Integer: IntegerType;
+            readonly Float: FloatType;
+            readonly String: StringType;
+            readonly DateTime: DateTimeType;
+            readonly Blob: BlobType;
         }>>>;
     }>;
-    insert: import("@elaraai/east").StructType<{
-        rowsAffected: IntegerType;
-        lastInsertId: import("@elaraai/east").OptionType<IntegerType>;
+    readonly insert: import("@elaraai/east").StructType<{
+        readonly rowsAffected: IntegerType;
+        readonly lastInsertId: OptionType<IntegerType>;
     }>;
-    update: import("@elaraai/east").StructType<{
-        rowsAffected: IntegerType;
+    readonly update: import("@elaraai/east").StructType<{
+        readonly rowsAffected: IntegerType;
     }>;
-    delete: import("@elaraai/east").StructType<{
-        rowsAffected: IntegerType;
+    readonly delete: import("@elaraai/east").StructType<{
+        readonly rowsAffected: IntegerType;
     }>;
 }>>;
+/**
+ * Executes a SELECT query with user-defined return type.
+ *
+ * Runs a SELECT query against a MySQL database with parameter binding and
+ * returns results as an array of typed rows. The return type is generic,
+ * allowing users to specify the expected row structure for type-safe access.
+ *
+ * This is a generic platform function for the East language, enabling type-safe
+ * SELECT queries in East programs running on Node.js.
+ *
+ * @typeParam T - The expected row type for query results
+ * @param handle - Connection handle from mysql_connect()
+ * @param sql - SQL SELECT query string with ? placeholders
+ * @param params - Query parameters as SqlParameterType array
+ * @returns Array of rows matching the specified type T
+ *
+ * @throws {EastError} When query fails due to:
+ * - Invalid connection handle (location: "mysql_select")
+ * - SQL syntax errors (location: "mysql_select")
+ * - Query is not a SELECT (location: "mysql_select")
+ * - Type coercion failure (location: "mysql_select")
+ *
+ * @example
+ * ```ts
+ * import { East, NullType, StructType, StringType, IntegerType, variant } from "@elaraai/east";
+ * import { SQL } from "@elaraai/east-node-io";
+ *
+ * // Define the expected row type
+ * const UserRowType = StructType({
+ *     id: IntegerType,
+ *     name: StringType,
+ *     email: StringType,
+ * });
+ *
+ * const queryUsers = East.function([], NullType, ($) => {
+ *     const config = $.let({
+ *         host: "localhost",
+ *         port: 3306n,
+ *         database: "myapp",
+ *         user: "root",
+ *         password: "secret",
+ *         ssl: variant('none', null),
+ *         maxConnections: variant('none', null),
+ *     });
+ *
+ *     const conn = $.let(SQL.MySQL.connect(config));
+ *
+ *     // Query with typed results - returns Array<UserRowType>
+ *     const users = $.let(SQL.MySQL.select([UserRowType], conn,
+ *         "SELECT id, name, email FROM users WHERE active = ?",
+ *         [variant('Boolean', true)]
+ *     ));
+ *     // users is typed as Array<{ id: bigint, name: string, email: string }>
+ *
+ *     $(SQL.MySQL.close(conn));
+ *     $.return(null);
+ * });
+ *
+ * const compiled = East.compileAsync(queryUsers.toIR(), SQL.MySQL.Implementation);
+ * await compiled();
+ * ```
+ *
+ * @remarks
+ * - Only SELECT queries are supported (use mysql_query for INSERT/UPDATE/DELETE)
+ * - Uses ? for parameter placeholders
+ * - Row type T should match the structure of selected columns
+ * - All MySQL data types are mapped to appropriate East types
+ * - NULL values are preserved in the result
+ */
+export declare const mysql_select: import("@elaraai/east").AsyncGenericPlatformDefinition<readonly ["T"], readonly [EastStringType, EastStringType, ArrayType<import("@elaraai/east").VariantType<{
+    readonly Null: NullType;
+    readonly Boolean: BooleanType;
+    readonly Integer: IntegerType;
+    readonly Float: FloatType;
+    readonly String: StringType;
+    readonly DateTime: DateTimeType;
+    readonly Blob: BlobType;
+}>>], ArrayType<"T">>;
 /**
  * Closes a MySQL connection pool.
  *

package/dist/src/sql/mysql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mysql.d.ts","sourceRoot":"","sources":["../../../src/sql/mysql.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;GAOG;AAEH,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,WAAW,EAAE,YAAY,EAAQ,SAAS,EAAE,WAAW,EAAsC,QAAQ,EAAE,UAAU,EAAa,UAAU,IAAI,cAAc,EAA4B,MAAM,eAAe,CAAC;AAE1O,OAAO,KAAK,EAAiB,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAI9E,OAAO,EAKH,UAAU,EAEb,MAAM,YAAY,CAAC;AA+BpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,eAAO,MAAM,aAAa;;;;;;;;oBAA+E,CAAC;AAE1G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA0G,CAAC;AAEnI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AACH,eAAO,MAAM,YAAY;;;;;;;;qBAKxB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,eAAO,MAAM,WAAW,6EAAsE,CAAC;AAE/F;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,eAAe,+DAAsD,CAAC;AAuFnF;;;;;GAKG;AACH,eAAO,MAAM,SAAS,EAAE,gBAAgB,EAkSvC,CAAC"}