kysely 0.28.17 → 0.29.0

package/dist/esm/plugin/parse-json-results/parse-json-results-plugin.js

@@ -1,104 +0,0 @@
-/// <reference types="./parse-json-results-plugin.d.ts" />
-import { isPlainObject, isString } from '../../util/object-utils.js';
-/**
- * Parses JSON strings in query results into JSON objects.
- *
- * This plugin can be useful with dialects that don't automatically parse
- * JSON into objects and arrays but return JSON strings instead.
- *
- * To apply this plugin globally, pass an instance of it to the `plugins` option
- * when creating a new `Kysely` instance:
- *
- * ```ts
- * import * as Sqlite from 'better-sqlite3'
- * import { Kysely, ParseJSONResultsPlugin, SqliteDialect } from 'kysely'
- * import type { Database } from 'type-editor' // imaginary module
- *
- * const db = new Kysely<Database>({
- *   dialect: new SqliteDialect({
- *     database: new Sqlite(':memory:'),
- *   }),
- *   plugins: [new ParseJSONResultsPlugin()],
- * })
- * ```
- *
- * To apply this plugin to a single query:
- *
- * ```ts
- * import { ParseJSONResultsPlugin } from 'kysely'
- * import { jsonArrayFrom } from 'kysely/helpers/sqlite'
- *
- * const result = await db
- *   .selectFrom('person')
- *   .select((eb) => [
- *     'id',
- *     'first_name',
- *     'last_name',
- *     jsonArrayFrom(
- *       eb.selectFrom('pet')
- *         .whereRef('owner_id', '=', 'person.id')
- *         .select(['name', 'species'])
- *     ).as('pets')
- *   ])
- *   .withPlugin(new ParseJSONResultsPlugin())
- *   .execute()
- * ```
- */
-export class ParseJSONResultsPlugin {
-    opt;
-    #objectStrategy;
-    constructor(opt = {}) {
-        this.opt = opt;
-        this.#objectStrategy = opt.objectStrategy || 'in-place';
-    }
-    // noop
-    transformQuery(args) {
-        return args.node;
-    }
-    async transformResult(args) {
-        return {
-            ...args.result,
-            rows: parseArray(args.result.rows, this.#objectStrategy),
-        };
-    }
-}
-function parseArray(arr, objectStrategy) {
-    const target = objectStrategy === 'create' ? new Array(arr.length) : arr;
-    for (let i = 0; i < arr.length; ++i) {
-        target[i] = parse(arr[i], objectStrategy);
-    }
-    return target;
-}
-function parse(obj, objectStrategy) {
-    if (isString(obj)) {
-        return parseString(obj);
-    }
-    if (Array.isArray(obj)) {
-        return parseArray(obj, objectStrategy);
-    }
-    if (isPlainObject(obj)) {
-        return parseObject(obj, objectStrategy);
-    }
-    return obj;
-}
-function parseString(str) {
-    if (maybeJson(str)) {
-        try {
-            return parse(JSON.parse(str), 'in-place');
-        }
-        catch (err) {
-            // this catch block is intentionally empty.
-        }
-    }
-    return str;
-}
-function maybeJson(value) {
-    return value.match(/^[\[\{]/) != null;
-}
-function parseObject(obj, objectStrategy) {
-    const target = objectStrategy === 'create' ? {} : obj;
-    for (const key in obj) {
-        target[key] = parse(obj[key], objectStrategy);
-    }
-    return target;
-}

package/dist/esm/plugin/with-schema/with-schema-plugin.d.ts

@@ -1,66 +0,0 @@
-import type { QueryResult } from '../../driver/database-connection.js';
-import type { RootOperationNode } from '../../query-compiler/query-compiler.js';
-import type { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } from '../kysely-plugin.js';
-import type { UnknownRow } from '../../util/type-utils.js';
-export declare class WithSchemaPlugin implements KyselyPlugin {
-    #private;
-    constructor(schema: string);
-    /**
-     * This is called for each query before it is executed. You can modify the query by
-     * transforming its {@link OperationNode} tree provided in {@link PluginTransformQueryArgs.node | args.node}
-     * and returning the transformed tree. You'd usually want to use an {@link OperationNodeTransformer}
-     * for this.
-     *
-     * If you need to pass some query-related data between this method and `transformResult` you
-     * can use a `WeakMap` with {@link PluginTransformQueryArgs.queryId | args.queryId} as the key:
-     *
-     * ```ts
-     * import type {
-     *   KyselyPlugin,
-     *   QueryResult,
-     *   RootOperationNode,
-     *   UnknownRow
-     * } from 'kysely'
-     *
-     * interface MyData {
-     *   // ...
-     * }
-     * const data = new WeakMap<any, MyData>()
-     *
-     * const plugin = {
-     *   transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
-     *     const something: MyData = {}
-     *
-     *     // ...
-     *
-     *     data.set(args.queryId, something)
-     *
-     *     // ...
-     *
-     *     return args.node
-     *   },
-     *
-     *   async transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>> {
-     *     // ...
-     *
-     *     const something = data.get(args.queryId)
-     *
-     *     // ...
-     *
-     *     return args.result
-     *   }
-     * } satisfies KyselyPlugin
-     * ```
-     *
-     * You should use a `WeakMap` instead of a `Map` or some other strong references because `transformQuery`
-     * is not always matched by a call to `transformResult` which would leave orphaned items in the map
-     * and cause a memory leak.
-     */
-    transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
-    /**
-     * This method is called for each query after it has been executed. The result
-     * of the query can be accessed through {@link PluginTransformResultArgs.result | args.result}.
-     * You can modify the result and return the modifier result.
-     */
-    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;
-}

package/dist/esm/plugin/with-schema/with-schema-transformer.d.ts

@@ -1,18 +0,0 @@
-import type { AggregateFunctionNode } from '../../operation-node/aggregate-function-node.js';
-import type { FunctionNode } from '../../operation-node/function-node.js';
-import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
-import type { OperationNode } from '../../operation-node/operation-node.js';
-import type { ReferencesNode } from '../../operation-node/references-node.js';
-import { SchemableIdentifierNode } from '../../operation-node/schemable-identifier-node.js';
-import type { SelectModifierNode } from '../../operation-node/select-modifier-node.js';
-import type { QueryId } from '../../util/query-id.js';
-export declare class WithSchemaTransformer extends OperationNodeTransformer {
-    #private;
-    constructor(schema: string);
-    protected transformNodeImpl<T extends OperationNode>(node: T, queryId: QueryId): T;
-    protected transformSchemableIdentifier(node: SchemableIdentifierNode, queryId: QueryId): SchemableIdentifierNode;
-    protected transformReferences(node: ReferencesNode, queryId: QueryId): ReferencesNode;
-    protected transformAggregateFunction(node: AggregateFunctionNode, queryId: QueryId): AggregateFunctionNode;
-    protected transformFunction(node: FunctionNode, queryId: QueryId): FunctionNode;
-    protected transformSelectModifier(node: SelectModifierNode, queryId: QueryId): SelectModifierNode;
-}

package/dist/esm/plugin/with-schema/with-schema-transformer.js

@@ -1,197 +0,0 @@
-/// <reference types="./with-schema-transformer.d.ts" />
-import { AliasNode } from '../../operation-node/alias-node.js';
-import { IdentifierNode } from '../../operation-node/identifier-node.js';
-import { JoinNode } from '../../operation-node/join-node.js';
-import { ListNode } from '../../operation-node/list-node.js';
-import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
-import { SchemableIdentifierNode } from '../../operation-node/schemable-identifier-node.js';
-import { TableNode } from '../../operation-node/table-node.js';
-import { UsingNode } from '../../operation-node/using-node.js';
-import { freeze } from '../../util/object-utils.js';
-// This object exist only so that we get a type error when a new RootOperationNode
-// is added. If you get a type error here, make sure to add the new root node and
-// handle it correctly in the transformer.
-//
-// DO NOT REFACTOR THIS EVEN IF IT SEEMS USELESS TO YOU!
-const ROOT_OPERATION_NODES = freeze({
-    AlterTableNode: true,
-    CreateIndexNode: true,
-    CreateSchemaNode: true,
-    CreateTableNode: true,
-    CreateTypeNode: true,
-    CreateViewNode: true,
-    RefreshMaterializedViewNode: true,
-    DeleteQueryNode: true,
-    DropIndexNode: true,
-    DropSchemaNode: true,
-    DropTableNode: true,
-    DropTypeNode: true,
-    DropViewNode: true,
-    InsertQueryNode: true,
-    RawNode: true,
-    SelectQueryNode: true,
-    UpdateQueryNode: true,
-    MergeQueryNode: true,
-});
-const SCHEMALESS_FUNCTIONS = {
-    json_agg: true,
-    to_json: true,
-};
-export class WithSchemaTransformer extends OperationNodeTransformer {
-    #schema;
-    #schemableIds = new Set();
-    #ctes = new Set();
-    constructor(schema) {
-        super();
-        this.#schema = schema;
-    }
-    transformNodeImpl(node, queryId) {
-        if (!this.#isRootOperationNode(node)) {
-            return super.transformNodeImpl(node, queryId);
-        }
-        const ctes = this.#collectCTEs(node);
-        for (const cte of ctes) {
-            this.#ctes.add(cte);
-        }
-        const tables = this.#collectSchemableIds(node);
-        for (const table of tables) {
-            this.#schemableIds.add(table);
-        }
-        const transformed = super.transformNodeImpl(node, queryId);
-        for (const table of tables) {
-            this.#schemableIds.delete(table);
-        }
-        for (const cte of ctes) {
-            this.#ctes.delete(cte);
-        }
-        return transformed;
-    }
-    transformSchemableIdentifier(node, queryId) {
-        const transformed = super.transformSchemableIdentifier(node, queryId);
-        if (transformed.schema || !this.#schemableIds.has(node.identifier.name)) {
-            return transformed;
-        }
-        return {
-            ...transformed,
-            schema: IdentifierNode.create(this.#schema),
-        };
-    }
-    transformReferences(node, queryId) {
-        const transformed = super.transformReferences(node, queryId);
-        if (transformed.table.table.schema) {
-            return transformed;
-        }
-        return {
-            ...transformed,
-            table: TableNode.createWithSchema(this.#schema, transformed.table.table.identifier.name),
-        };
-    }
-    transformAggregateFunction(node, queryId) {
-        return {
-            ...super.transformAggregateFunction({ ...node, aggregated: [] }, queryId),
-            aggregated: this.#transformTableArgsWithoutSchemas(node, queryId, 'aggregated'),
-        };
-    }
-    transformFunction(node, queryId) {
-        return {
-            ...super.transformFunction({ ...node, arguments: [] }, queryId),
-            arguments: this.#transformTableArgsWithoutSchemas(node, queryId, 'arguments'),
-        };
-    }
-    transformSelectModifier(node, queryId) {
-        return {
-            ...super.transformSelectModifier({ ...node, of: undefined }, queryId),
-            of: node.of?.map((item) => TableNode.is(item) && !item.table.schema
-                ? {
-                    ...item,
-                    table: this.transformIdentifier(item.table.identifier, queryId),
-                }
-                : this.transformNode(item, queryId)),
-        };
-    }
-    #transformTableArgsWithoutSchemas(node, queryId, argsKey) {
-        return SCHEMALESS_FUNCTIONS[node.func]
-            ? node[argsKey].map((arg) => !TableNode.is(arg) || arg.table.schema
-                ? this.transformNode(arg, queryId)
-                : {
-                    ...arg,
-                    table: this.transformIdentifier(arg.table.identifier, queryId),
-                })
-            : this.transformNodeList(node[argsKey], queryId);
-    }
-    #isRootOperationNode(node) {
-        return node.kind in ROOT_OPERATION_NODES;
-    }
-    #collectSchemableIds(node) {
-        const schemableIds = new Set();
-        if ('name' in node && node.name && SchemableIdentifierNode.is(node.name)) {
-            this.#collectSchemableId(node.name, schemableIds);
-        }
-        if ('from' in node && node.from) {
-            for (const from of node.from.froms) {
-                this.#collectSchemableIdsFromTableExpr(from, schemableIds);
-            }
-        }
-        if ('into' in node && node.into) {
-            this.#collectSchemableIdsFromTableExpr(node.into, schemableIds);
-        }
-        if ('table' in node && node.table) {
-            this.#collectSchemableIdsFromTableExpr(node.table, schemableIds);
-        }
-        if ('joins' in node && node.joins) {
-            for (const join of node.joins) {
-                this.#collectSchemableIdsFromTableExpr(join.table, schemableIds);
-            }
-        }
-        if ('using' in node && node.using) {
-            if (JoinNode.is(node.using)) {
-                this.#collectSchemableIdsFromTableExpr(node.using.table, schemableIds);
-            }
-            else {
-                this.#collectSchemableIdsFromTableExpr(node.using, schemableIds);
-            }
-        }
-        return schemableIds;
-    }
-    #collectCTEs(node) {
-        const ctes = new Set();
-        if ('with' in node && node.with) {
-            this.#collectCTEIds(node.with, ctes);
-        }
-        return ctes;
-    }
-    #collectSchemableIdsFromTableExpr(node, schemableIds) {
-        if (TableNode.is(node)) {
-            return this.#collectSchemableId(node.table, schemableIds);
-        }
-        if (AliasNode.is(node) && TableNode.is(node.node)) {
-            return this.#collectSchemableId(node.node.table, schemableIds);
-        }
-        if (ListNode.is(node)) {
-            for (const table of node.items) {
-                this.#collectSchemableIdsFromTableExpr(table, schemableIds);
-            }
-            return;
-        }
-        if (UsingNode.is(node)) {
-            for (const table of node.tables) {
-                this.#collectSchemableIdsFromTableExpr(table, schemableIds);
-            }
-            return;
-        }
-    }
-    #collectSchemableId(node, schemableIds) {
-        const id = node.identifier.name;
-        if (!this.#schemableIds.has(id) && !this.#ctes.has(id)) {
-            schemableIds.add(id);
-        }
-    }
-    #collectCTEIds(node, ctes) {
-        for (const expr of node.expressions) {
-            const cteId = expr.name.table.table.identifier.name;
-            if (!this.#ctes.has(cteId)) {
-                ctes.add(cteId);
-            }
-        }
-    }
-}