@flowblade/sqlduck 0.11.0 → 0.12.0

package/dist/index.d.cts

@@ -1,345 +0,0 @@
-import * as _duckdb_node_api0 from "@duckdb/node-api";
-import { DuckDBConnection, DuckDBType } from "@duckdb/node-api";
-import * as _logtape_logtape0 from "@logtape/logtape";
-import { Logger } from "@logtape/logtape";
-import * as z from "zod";
-import { ZodObject } from "zod";
-
-//#region src/appender/data-appender-callback.d.ts
-type OnDataAppendedStats = {
-  /**
-   * Total number of rows appended so far (all batches included)
-   */
-  totalRows: number;
-  /**
-   * Time taken to append the last batch in milliseconds
-   */
-  timeMs: number;
-  /**
-   * Estimated rows per seconds based on the current batch
-   */
-  rowsPerSecond: number;
-};
-type OnDataAppendedSyncCb = (stats: OnDataAppendedStats) => void;
-type OnDataAppendedAsyncCb = (stats: OnDataAppendedStats) => Promise<void>;
-type OnDataAppendedCb = OnDataAppendedSyncCb | OnDataAppendedAsyncCb;
-//#endregion
-//#region src/helpers/duck-memory.d.ts
-declare const duckMemoryTags: readonly ["BASE_TABLE", "HASH_TABLE", "PARQUET_READER", "CSV_READER", "ORDER_BY", "ART_INDEX", "COLUMN_DATA", "METADATA", "OVERFLOW_STRINGS", "IN_MEMORY_TABLE", "ALLOCATOR", "EXTENSION", "TRANSACTION", "EXTERNAL_FILE_CACHE", "WINDOW", "OBJECT_CACHE"];
-type DuckMemoryTag = (typeof duckMemoryTags)[number];
-type DuckMemoryRow = {
-  tag: DuckMemoryTag;
-  memory_usage_bytes: bigint;
-  temporary_storage_bytes: bigint;
-};
-declare const orderByParams: {
-  memory_usage_bytes_desc: string;
-  tag_desc: string;
-  tag_asc: string;
-};
-type OrderByParams = keyof typeof orderByParams;
-type DuckMemorySummary = {
-  totalMB: number;
-  totalTempMB: number;
-};
-declare class DuckMemory {
-  #private;
-  constructor(duckdbConn: DuckDBConnection);
-  getAll: (params?: {
-    orderBy?: OrderByParams;
-  }) => Promise<DuckMemoryRow[]>;
-  getByTag: (tag: DuckMemoryTag) => Promise<DuckMemoryRow | null>;
-  getSummary: () => Promise<DuckMemorySummary>;
-}
-//#endregion
-//#region src/objects/table.d.ts
-/**
- * Fully qualified table information
- */
-type FQTable = {
-  name: string;
-  schema?: string;
-  database?: string;
-};
-declare class Table {
-  #private;
-  get tableName(): string;
-  get schemaName(): string | undefined;
-  get databaseName(): string | undefined;
-  constructor(fqTableOrName: FQTable | string);
-  /**
-   * Return fully qualified table name by concatenating
-   * database, schema and table with a 'dot' separator.
-   */
-  getFullName: (options?: {
-    defaultDatabase?: string;
-    defaultSchema?: string;
-  }) => string;
-  withDatabase: (database: string) => Table;
-  withSchema: (schema: string) => Table;
-}
-//#endregion
-//#region src/table/table-schema-zod.type.d.ts
-type ZodSchemaSupportedTypes = z.ZodString | z.ZodNumber | z.ZodInt | z.ZodInt32 | z.ZodUInt32 | z.ZodBigInt | z.ZodBoolean | z.ZodDate | z.ZodISODateTime | z.ZodISOTime | z.ZodISODate | z.ZodEmail | z.ZodURL | z.ZodUUID | z.ZodCUID | z.ZodCUID2 | z.ZodULID;
-type TableSchemaZod = z.ZodObject<Record<string, ZodSchemaSupportedTypes | z.ZodNullable<ZodSchemaSupportedTypes> | z.ZodCodec | z.ZodNullable<z.ZodCodec>>>;
-//#endregion
-//#region src/table/get-table-create-from-zod.d.ts
-type TableCreateOptions = {
-  create?: 'CREATE' | 'CREATE_OR_REPLACE' | 'IF_NOT_EXISTS';
-};
-type DuckdbColumnTypeMap<TKeys extends string> = Map<TKeys, DuckDBType>;
-type TableCreateFromZodResult<TSchema extends TableSchemaZod> = {
-  ddl: string;
-  columnTypes: DuckdbColumnTypeMap<Exclude<keyof TSchema['shape'], symbol | number>>;
-};
-type GetTableCreateFromZodParams<TSchema extends TableSchemaZod> = {
-  table: Table;
-  schema: TSchema;
-  options?: TableCreateOptions;
-};
-declare const getTableCreateFromZod: <TSchema extends TableSchemaZod>(params: GetTableCreateFromZodParams<TSchema>) => TableCreateFromZodResult<TSchema>;
-//#endregion
-//#region src/sql-duck.d.ts
-type SqlDuckParams = {
-  conn: DuckDBConnection;
-  /**
-   * Optional logtape/logger to use for logging.
-   * If not provided, a default logger will be used.
-   * @see {@link https://github.com/logtape/logtape}
-   */
-  logger?: Logger;
-};
-type RowStream<T> = AsyncIterableIterator<T> | AsyncGenerator<T> | Generator<T>;
-type ToTableParams<TSchema extends TableSchemaZod> = {
-  /**
-   * Used to create and fill the data into the table
-   */
-  table: Table;
-  /**
-   * Schema describing the table structure and rowStream content
-   */
-  schema: TSchema;
-  /**
-   * Stream of rows to insert into the table
-   */
-  rowStream: RowStream<z.infer<TSchema>>;
-  /**
-   * Chunk size when using appender to insert data.
-   * Valid numbers between 1 and 2048.
-   * @default 2048
-   */
-  chunkSize?: number;
-  /**
-   * Extra options when creating the table
-   */
-  createOptions?: TableCreateOptions;
-  /**
-   * Callback called each time a datachunk is appended to the table
-   */
-  onDataAppended?: OnDataAppendedCb;
-};
-type ToTableResult = {
-  /**
-   * Total time taken to insert the data in milliseconds.
-   */
-  timeMs: number;
-  /**
-   * Total number of rows inserted into the table.
-   */
-  totalRows: number;
-  /**
-   * The DDL statement used to create the table.
-   */
-  createTableDDL: string;
-};
-declare class SqlDuck {
-  #private;
-  constructor(params: SqlDuckParams);
-  /**
-   * Create a table from a Zod schema and fill it with data from a row stream.
-   *
-   * @example
-   * ```typescript
-   * import * as z from 'zod';
-   *
-   * const sqlDuck = new SqlDuck({ conn: duckDbConnection });
-   *
-   * // Schema of the table, not that you can use meta to add information
-   * const userSchema = z.object({
-   *  id: z.number().int().meta({ primaryKey: true }),
-   *  name: z.string(),
-   * });
-   *
-   * // Async generator function that yields rows to insert
-   * async function* getUserRows(): AsyncIterableIterator<z.infer<typeof userSchema>> {
-   *   // database or api call
-   * }
-   *
-   * const result = sqlDuck.toTable({
-   *  table: new Table({ name: 'user', database: 'mydb' }),
-   *  schema: userSchema,
-   *  rowStream: getUserRows(),
-   *  chunkSize: 2048,
-   *  onDataAppended: ({ total }) => {
-   *    console.log(`Appended ${total} rows so far`);
-   *  },
-   *  createOptions: {
-   *    create: 'CREATE_OR_REPLACE',
-   *  },
-   * });
-   *
-   * console.log(`Inserted ${result.totalRows} rows in ${result.timeMs}ms`);
-   * console.log(`Table created with DDL: ${result.createTableDDL}`);
-   * ```
-   */
-  toTable: <TSchema extends ZodObject>(params: ToTableParams<TSchema>) => Promise<ToTableResult>;
-}
-//#endregion
-//#region src/utils/zod-codecs.d.ts
-declare const zodCodecs: {
-  readonly dateToString: z.ZodCodec<z.ZodDate, z.ZodISODateTime>;
-  readonly bigintToString: z.ZodCodec<z.ZodBigInt, z.ZodString>;
-};
-//#endregion
-//#region src/objects/database.d.ts
-type DatabaseProperties = {
-  alias: string;
-};
-declare class Database {
-  #private;
-  get alias(): string;
-  constructor(params: DatabaseProperties);
-  toJson(): {
-    type: string;
-    params: {
-      alias: string;
-    };
-  };
-  [Symbol.toStringTag](): string;
-}
-//#endregion
-//#region src/manager/database/duck-database-manager.schemas.d.ts
-declare const duckDatabaseManagerDbParamsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-  type: z.ZodLiteral<":memory:">;
-  alias: z.ZodString;
-  options: z.ZodOptional<z.ZodObject<{
-    ACCESS_MODE: z.ZodOptional<z.ZodEnum<{
-      READ_ONLY: "READ_ONLY";
-      READ_WRITE: "READ_WRITE";
-      AUTOMATIC: "AUTOMATIC";
-    }>>;
-    COMPRESS: z.ZodOptional<z.ZodEnum<{
-      true: "true";
-      false: "false";
-    }>>;
-    TYPE: z.ZodOptional<z.ZodEnum<{
-      DUCKDB: "DUCKDB";
-      SQLITE: "SQLITE";
-    }>>;
-    BLOCK_SIZE: z.ZodOptional<z.ZodInt32>;
-    ROW_GROUP_SIZE: z.ZodOptional<z.ZodInt32>;
-    STORAGE_VERSION: z.ZodOptional<z.ZodString>;
-    ENCRYPTION_KEY: z.ZodOptional<z.ZodString>;
-    ENCRYPTION_CIPHER: z.ZodOptional<z.ZodEnum<{
-      CBC: "CBC";
-      CTR: "CTR";
-      GCM: "GCM";
-    }>>;
-  }, z.core.$strict>>;
-}, z.core.$strict>, z.ZodObject<{
-  type: z.ZodLiteral<"duckdb">;
-  path: z.ZodString;
-  alias: z.ZodString;
-  options: z.ZodOptional<z.ZodObject<{
-    ACCESS_MODE: z.ZodOptional<z.ZodEnum<{
-      READ_ONLY: "READ_ONLY";
-      READ_WRITE: "READ_WRITE";
-      AUTOMATIC: "AUTOMATIC";
-    }>>;
-    COMPRESS: z.ZodOptional<z.ZodEnum<{
-      true: "true";
-      false: "false";
-    }>>;
-    TYPE: z.ZodOptional<z.ZodEnum<{
-      DUCKDB: "DUCKDB";
-      SQLITE: "SQLITE";
-    }>>;
-    BLOCK_SIZE: z.ZodOptional<z.ZodInt32>;
-    ROW_GROUP_SIZE: z.ZodOptional<z.ZodInt32>;
-    STORAGE_VERSION: z.ZodOptional<z.ZodString>;
-    ENCRYPTION_KEY: z.ZodOptional<z.ZodString>;
-    ENCRYPTION_CIPHER: z.ZodOptional<z.ZodEnum<{
-      CBC: "CBC";
-      CTR: "CTR";
-      GCM: "GCM";
-    }>>;
-  }, z.core.$strict>>;
-}, z.core.$strict>], "type">;
-type DuckDatabaseManagerDbParams = z.infer<typeof duckDatabaseManagerDbParamsSchema>;
-//#endregion
-//#region src/manager/database/commands/duck-database-attach-command.d.ts
-type Behaviour = 'OR REPLACE' | 'IF NOT EXISTS';
-type DuckDatabaseAttachCommandOptions = {
-  behaviour?: Behaviour;
-};
-//#endregion
-//#region src/manager/database/duck-database-manager.d.ts
-declare class DuckDatabaseManager {
-  #private;
-  constructor(conn: DuckDBConnection, params?: {
-    logger?: Logger;
-  });
-  /**
-   * Attach a database to the current connection
-   *
-   * @example
-   * ```typescript
-   * const dbManager = new DuckDatabaseManager(conn);
-   * const database = dbManager.attach({
-   *   type: ':memory:', // can be 'duckdb', 's3'...
-   *   alias: 'mydb',
-   *   options: { COMPRESS: 'true' }
-   * });
-   *
-   * console.log(database.alias); // 'mydb'
-   * ```
-   */
-  attach: (dbParams: DuckDatabaseManagerDbParams, options?: DuckDatabaseAttachCommandOptions) => Promise<Database>;
-  attachOrReplace: (dbParams: DuckDatabaseManagerDbParams) => Promise<Database>;
-  attachIfNotExists: (dbParams: DuckDatabaseManagerDbParams) => Promise<Database>;
-  showDatabases: () => Promise<Record<string, _duckdb_node_api0.JS>[]>;
-  detach: (dbAlias: string) => Promise<boolean>;
-  detachIfExists: (dbAlias: string) => Promise<boolean>;
-  /**
-   * The statistics recomputed by the ANALYZE statement are only used for join order optimization.
-   *
-   * It is therefore recommended to recompute these statistics for improved join orders,
-   * especially after performing large updates (inserts and/or deletes).
-   *
-   * @link https://duckdb.org/docs/stable/sql/statements/analyze
-   */
-  analyze: () => Promise<boolean>;
-  checkpoint: (dbAlias: string) => Promise<boolean>;
-}
-//#endregion
-//#region src/validation/core/duckdb-reserved-keywords.d.ts
-/**
- * DuckDB reserved keywords that cannot be used as unquoted identifiers.
- * @see https://duckdb.org/docs/sql/keywords-and-identifiers.html
- */
-declare const duckdbReservedKeywords: readonly ["ALL", "ANALYSE", "ANALYZE", "AND", "ANY", "ARRAY", "AS", "ASC", "ASYMMETRIC", "BOTH", "CASE", "CAST", "CHECK", "COLLATE", "COLUMN", "CONSTRAINT", "CREATE", "CROSS", "CURRENT_CATALOG", "CURRENT_DATE", "CURRENT_ROLE", "CURRENT_SCHEMA", "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_USER", "DEFAULT", "DEFERRABLE", "DESC", "DISTINCT", "DO", "ELSE", "END", "EXCEPT", "EXISTS", "EXTRACT", "FALSE", "FETCH", "FOR", "FOREIGN", "FROM", "GRANT", "GROUP", "HAVING", "IF", "ILIKE", "IN", "INITIALLY", "INNER", "INTERSECT", "INTO", "IS", "ISNULL", "JOIN", "LATERAL", "LEADING", "LEFT", "LIKE", "LIMIT", "LOCALTIME", "LOCALTIMESTAMP", "NATURAL", "NOT", "NOTNULL", "NULL", "OFFSET", "ON", "ONLY", "OR", "ORDER", "OUTER", "OVERLAPS", "PLACING", "PRIMARY", "REFERENCES", "RETURNING", "RIGHT", "ROW", "SELECT", "SESSION_USER", "SIMILAR", "SOME", "SYMMETRIC", "TABLE", "THEN", "TO", "TRAILING", "TRUE", "UNION", "UNIQUE", "USING", "VARIADIC", "VERBOSE", "WHEN", "WHERE", "WINDOW", "WITH"];
-type DuckdbReservedKeywords = (typeof duckdbReservedKeywords)[number];
-//#endregion
-//#region src/validation/zod/duckdb-valid-names.schemas.d.ts
-declare const duckTableNameSchema: z.ZodString;
-declare const duckTableAliasSchema: z.ZodString;
-//#endregion
-//#region src/config/flowblade-logtape-sqlduck.config.d.ts
-declare const flowbladeLogtapeSqlduckConfig: {
-  categories: string[];
-};
-//#endregion
-//#region src/logger/sqlduck-default-logtape-logger.d.ts
-declare const sqlduckDefaultLogtapeLogger: _logtape_logtape0.Logger;
-//#endregion
-export { Database, DuckDatabaseManager, type DuckDatabaseManagerDbParams, DuckMemory, DuckMemoryTag, type DuckdbReservedKeywords, type OnDataAppendedCb, type OnDataAppendedStats, SqlDuck, type SqlDuckParams, Table, type ToTableParams, duckDatabaseManagerDbParamsSchema, duckTableAliasSchema, duckTableNameSchema, duckdbReservedKeywords, flowbladeLogtapeSqlduckConfig, getTableCreateFromZod, sqlduckDefaultLogtapeLogger, zodCodecs };