@pleaseai/agent 0.1.16 → 0.1.17

package/.output/server/node_modules/kysely/dist/esm/query-executor/query-executor-base.js

@@ -0,0 +1,59 @@
+/// <reference types="./query-executor-base.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { provideControlledConnection } from '../util/provide-controlled-connection.js';
+import { logOnce } from '../util/log-once.js';
+const NO_PLUGINS = freeze([]);
+export class QueryExecutorBase {
+    #plugins;
+    constructor(plugins = NO_PLUGINS) {
+        this.#plugins = plugins;
+    }
+    get plugins() {
+        return this.#plugins;
+    }
+    transformQuery(node, queryId) {
+        for (const plugin of this.#plugins) {
+            const transformedNode = plugin.transformQuery({ node, queryId });
+            // We need to do a runtime check here. There is no good way
+            // to write types that enforce this constraint.
+            if (transformedNode.kind === node.kind) {
+                node = transformedNode;
+            }
+            else {
+                throw new Error([
+                    `KyselyPlugin.transformQuery must return a node`,
+                    `of the same kind that was given to it.`,
+                    `The plugin was given a ${node.kind}`,
+                    `but it returned a ${transformedNode.kind}`,
+                ].join(' '));
+            }
+        }
+        return node;
+    }
+    async executeQuery(compiledQuery) {
+        return await this.provideConnection(async (connection) => {
+            const result = await connection.executeQuery(compiledQuery);
+            if ('numUpdatedOrDeletedRows' in result) {
+                logOnce('kysely:warning: outdated driver/plugin detected! `QueryResult.numUpdatedOrDeletedRows` has been replaced with `QueryResult.numAffectedRows`.');
+            }
+            return await this.#transformResult(result, compiledQuery.queryId);
+        });
+    }
+    async *stream(compiledQuery, chunkSize) {
+        const { connection, release } = await provideControlledConnection(this);
+        try {
+            for await (const result of connection.streamQuery(compiledQuery, chunkSize)) {
+                yield await this.#transformResult(result, compiledQuery.queryId);
+            }
+        }
+        finally {
+            release();
+        }
+    }
+    async #transformResult(result, queryId) {
+        for (const plugin of this.#plugins) {
+            result = await plugin.transformResult({ result, queryId });
+        }
+        return result;
+    }
+}

package/.output/server/node_modules/kysely/dist/esm/query-executor/query-executor-provider.js

@@ -0,0 +1,2 @@
+/// <reference types="./query-executor-provider.d.ts" />
+export {};

package/.output/server/node_modules/kysely/dist/esm/query-executor/query-executor.js

@@ -0,0 +1,2 @@
+/// <reference types="./query-executor.d.ts" />
+export {};

package/.output/server/node_modules/kysely/dist/esm/raw-builder/raw-builder.js

@@ -0,0 +1,84 @@
+/// <reference types="./raw-builder.d.ts" />
+import { AliasNode } from '../operation-node/alias-node.js';
+import { freeze } from '../util/object-utils.js';
+import { NOOP_QUERY_EXECUTOR } from '../query-executor/noop-query-executor.js';
+import { IdentifierNode } from '../operation-node/identifier-node.js';
+import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
+class RawBuilderImpl {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    get expressionType() {
+        return undefined;
+    }
+    get isRawBuilder() {
+        return true;
+    }
+    as(alias) {
+        return new AliasedRawBuilderImpl(this, alias);
+    }
+    $castTo() {
+        return new RawBuilderImpl({ ...this.#props });
+    }
+    $notNull() {
+        return new RawBuilderImpl(this.#props);
+    }
+    withPlugin(plugin) {
+        return new RawBuilderImpl({
+            ...this.#props,
+            plugins: this.#props.plugins !== undefined
+                ? freeze([...this.#props.plugins, plugin])
+                : freeze([plugin]),
+        });
+    }
+    toOperationNode() {
+        return this.#toOperationNode(this.#getExecutor());
+    }
+    compile(executorProvider) {
+        return this.#compile(this.#getExecutor(executorProvider));
+    }
+    async execute(executorProvider) {
+        const executor = this.#getExecutor(executorProvider);
+        return executor.executeQuery(this.#compile(executor));
+    }
+    #getExecutor(executorProvider) {
+        const executor = executorProvider !== undefined
+            ? executorProvider.getExecutor()
+            : NOOP_QUERY_EXECUTOR;
+        return this.#props.plugins !== undefined
+            ? executor.withPlugins(this.#props.plugins)
+            : executor;
+    }
+    #toOperationNode(executor) {
+        return executor.transformQuery(this.#props.rawNode, this.#props.queryId);
+    }
+    #compile(executor) {
+        return executor.compileQuery(this.#toOperationNode(executor), this.#props.queryId);
+    }
+}
+export function createRawBuilder(props) {
+    return new RawBuilderImpl(props);
+}
+class AliasedRawBuilderImpl {
+    #rawBuilder;
+    #alias;
+    constructor(rawBuilder, alias) {
+        this.#rawBuilder = rawBuilder;
+        this.#alias = alias;
+    }
+    get expression() {
+        return this.#rawBuilder;
+    }
+    get alias() {
+        return this.#alias;
+    }
+    get rawBuilder() {
+        return this.#rawBuilder;
+    }
+    toOperationNode() {
+        return AliasNode.create(this.#rawBuilder.toOperationNode(), isOperationNodeSource(this.#alias)
+            ? this.#alias.toOperationNode()
+            : IdentifierNode.create(this.#alias));
+    }
+}

package/.output/server/node_modules/kysely/dist/esm/raw-builder/sql.js

@@ -0,0 +1,82 @@
+/// <reference types="./sql.d.ts" />
+import { IdentifierNode } from '../operation-node/identifier-node.js';
+import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
+import { RawNode } from '../operation-node/raw-node.js';
+import { ValueNode } from '../operation-node/value-node.js';
+import { parseStringReference } from '../parser/reference-parser.js';
+import { parseTable } from '../parser/table-parser.js';
+import { parseValueExpression } from '../parser/value-parser.js';
+import { createQueryId } from '../util/query-id.js';
+import { createRawBuilder } from './raw-builder.js';
+export const sql = Object.assign((sqlFragments, ...parameters) => {
+    return createRawBuilder({
+        queryId: createQueryId(),
+        rawNode: RawNode.create(sqlFragments, parameters?.map(parseParameter) ?? []),
+    });
+}, {
+    ref(columnReference) {
+        return createRawBuilder({
+            queryId: createQueryId(),
+            rawNode: RawNode.createWithChild(parseStringReference(columnReference)),
+        });
+    },
+    val(value) {
+        return createRawBuilder({
+            queryId: createQueryId(),
+            rawNode: RawNode.createWithChild(parseValueExpression(value)),
+        });
+    },
+    value(value) {
+        return this.val(value);
+    },
+    table(tableReference) {
+        return createRawBuilder({
+            queryId: createQueryId(),
+            rawNode: RawNode.createWithChild(parseTable(tableReference)),
+        });
+    },
+    id(...ids) {
+        const fragments = new Array(ids.length + 1).fill('.');
+        fragments[0] = '';
+        fragments[fragments.length - 1] = '';
+        return createRawBuilder({
+            queryId: createQueryId(),
+            rawNode: RawNode.create(fragments, ids.map(IdentifierNode.create)),
+        });
+    },
+    lit(value) {
+        return createRawBuilder({
+            queryId: createQueryId(),
+            rawNode: RawNode.createWithChild(ValueNode.createImmediate(value)),
+        });
+    },
+    literal(value) {
+        return this.lit(value);
+    },
+    raw(sql) {
+        return createRawBuilder({
+            queryId: createQueryId(),
+            rawNode: RawNode.createWithSql(sql),
+        });
+    },
+    join(array, separator = sql `, `) {
+        const nodes = new Array(Math.max(2 * array.length - 1, 0));
+        const sep = separator.toOperationNode();
+        for (let i = 0; i < array.length; ++i) {
+            nodes[2 * i] = parseParameter(array[i]);
+            if (i !== array.length - 1) {
+                nodes[2 * i + 1] = sep;
+            }
+        }
+        return createRawBuilder({
+            queryId: createQueryId(),
+            rawNode: RawNode.createWithChildren(nodes),
+        });
+    },
+});
+function parseParameter(param) {
+    if (isOperationNodeSource(param)) {
+        return param.toOperationNode();
+    }
+    return parseValueExpression(param);
+}

package/.output/server/node_modules/kysely/dist/esm/schema/alter-column-builder.js

@@ -0,0 +1,70 @@
+/// <reference types="./alter-column-builder.d.ts" />
+import { AlterColumnNode } from '../operation-node/alter-column-node.js';
+import { parseDataTypeExpression, } from '../parser/data-type-parser.js';
+import { parseDefaultValueExpression, } from '../parser/default-value-parser.js';
+export class AlterColumnBuilder {
+    #column;
+    constructor(column) {
+        this.#column = column;
+    }
+    setDataType(dataType) {
+        return new AlteredColumnBuilder(AlterColumnNode.create(this.#column, 'dataType', parseDataTypeExpression(dataType)));
+    }
+    setDefault(value) {
+        return new AlteredColumnBuilder(AlterColumnNode.create(this.#column, 'setDefault', parseDefaultValueExpression(value)));
+    }
+    dropDefault() {
+        return new AlteredColumnBuilder(AlterColumnNode.create(this.#column, 'dropDefault', true));
+    }
+    setNotNull() {
+        return new AlteredColumnBuilder(AlterColumnNode.create(this.#column, 'setNotNull', true));
+    }
+    dropNotNull() {
+        return new AlteredColumnBuilder(AlterColumnNode.create(this.#column, 'dropNotNull', true));
+    }
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call(func) {
+        return func(this);
+    }
+}
+/**
+ * Allows us to force consumers to do exactly one alteration to a column.
+ *
+ * One cannot do no alterations:
+ *
+ * ```ts
+ * await db.schema
+ *   .alterTable('person')
+ * //  .execute() // Property 'execute' does not exist on type 'AlteredColumnBuilder'.
+ * ```
+ *
+ * ```ts
+ * await db.schema
+ *   .alterTable('person')
+ * //  .alterColumn('age', (ac) => ac) // Type 'AlterColumnBuilder' is not assignable to type 'AlteredColumnBuilder'.
+ * //  .execute()
+ * ```
+ *
+ * One cannot do multiple alterations:
+ *
+ * ```ts
+ * await db.schema
+ *   .alterTable('person')
+ * //  .alterColumn('age', (ac) => ac.dropNotNull().setNotNull()) // Property 'setNotNull' does not exist on type 'AlteredColumnBuilder'.
+ * //  .execute()
+ * ```
+ *
+ * Which would now throw a compilation error, instead of a runtime error.
+ */
+export class AlteredColumnBuilder {
+    #alterColumnNode;
+    constructor(alterColumnNode) {
+        this.#alterColumnNode = alterColumnNode;
+    }
+    toOperationNode() {
+        return this.#alterColumnNode;
+    }
+}

package/.output/server/node_modules/kysely/dist/esm/schema/alter-table-add-foreign-key-constraint-builder.js

@@ -0,0 +1,64 @@
+/// <reference types="./alter-table-add-foreign-key-constraint-builder.d.ts" />
+import { AddConstraintNode } from '../operation-node/add-constraint-node.js';
+import { AlterTableNode } from '../operation-node/alter-table-node.js';
+import { freeze } from '../util/object-utils.js';
+export class AlterTableAddForeignKeyConstraintBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    onDelete(onDelete) {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.onDelete(onDelete),
+        });
+    }
+    onUpdate(onUpdate) {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.onUpdate(onUpdate),
+        });
+    }
+    deferrable() {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.deferrable(),
+        });
+    }
+    notDeferrable() {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.notDeferrable(),
+        });
+    }
+    initiallyDeferred() {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.initiallyDeferred(),
+        });
+    }
+    initiallyImmediate() {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.initiallyImmediate(),
+        });
+    }
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call(func) {
+        return func(this);
+    }
+    toOperationNode() {
+        return this.#props.executor.transformQuery(AlterTableNode.cloneWithTableProps(this.#props.node, {
+            addConstraint: AddConstraintNode.create(this.#props.constraintBuilder.toOperationNode()),
+        }), this.#props.queryId);
+    }
+    compile() {
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
+    }
+    async execute() {
+        await this.#props.executor.executeQuery(this.compile());
+    }
+}

package/.output/server/node_modules/kysely/dist/esm/schema/alter-table-add-index-builder.js

@@ -0,0 +1,162 @@
+/// <reference types="./alter-table-add-index-builder.d.ts" />
+import { AddIndexNode } from '../operation-node/add-index-node.js';
+import { AlterTableNode } from '../operation-node/alter-table-node.js';
+import { RawNode } from '../operation-node/raw-node.js';
+import { parseOrderedColumnName, } from '../parser/reference-parser.js';
+import { freeze } from '../util/object-utils.js';
+export class AlterTableAddIndexBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    /**
+     * Makes the index unique.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *   .alterTable('person')
+     *   .addIndex('person_first_name_index')
+     *   .unique()
+     *   .column('email')
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * alter table `person` add unique index `person_first_name_index` (`email`)
+     * ```
+     */
+    unique() {
+        return new AlterTableAddIndexBuilder({
+            ...this.#props,
+            node: AlterTableNode.cloneWithTableProps(this.#props.node, {
+                addIndex: AddIndexNode.cloneWith(this.#props.node.addIndex, {
+                    unique: true,
+                }),
+            }),
+        });
+    }
+    /**
+     * Adds a column to the index.
+     *
+     * Also see {@link columns} for adding multiple columns at once or {@link expression}
+     * for specifying an arbitrary expression.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *   .alterTable('person')
+     *   .addIndex('person_first_name_and_age_index')
+     *   .column('first_name')
+     *   .column('age desc')
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * alter table `person` add index `person_first_name_and_age_index` (`first_name`, `age` desc)
+     * ```
+     */
+    column(column) {
+        return new AlterTableAddIndexBuilder({
+            ...this.#props,
+            node: AlterTableNode.cloneWithTableProps(this.#props.node, {
+                addIndex: AddIndexNode.cloneWithColumns(this.#props.node.addIndex, [
+                    parseOrderedColumnName(column),
+                ]),
+            }),
+        });
+    }
+    /**
+     * Specifies a list of columns for the index.
+     *
+     * Also see {@link column} for adding a single column or {@link expression} for
+     * specifying an arbitrary expression.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *   .alterTable('person')
+     *   .addIndex('person_first_name_and_age_index')
+     *   .columns(['first_name', 'age desc'])
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * alter table `person` add index `person_first_name_and_age_index` (`first_name`, `age` desc)
+     * ```
+     */
+    columns(columns) {
+        return new AlterTableAddIndexBuilder({
+            ...this.#props,
+            node: AlterTableNode.cloneWithTableProps(this.#props.node, {
+                addIndex: AddIndexNode.cloneWithColumns(this.#props.node.addIndex, columns.map(parseOrderedColumnName)),
+            }),
+        });
+    }
+    /**
+     * Specifies an arbitrary expression for the index.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * await db.schema
+     *   .alterTable('person')
+     *   .addIndex('person_first_name_index')
+     *   .expression(sql<boolean>`(first_name < 'Sami')`)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * alter table `person` add index `person_first_name_index` ((first_name < 'Sami'))
+     * ```
+     */
+    expression(expression) {
+        return new AlterTableAddIndexBuilder({
+            ...this.#props,
+            node: AlterTableNode.cloneWithTableProps(this.#props.node, {
+                addIndex: AddIndexNode.cloneWithColumns(this.#props.node.addIndex, [
+                    expression.toOperationNode(),
+                ]),
+            }),
+        });
+    }
+    using(indexType) {
+        return new AlterTableAddIndexBuilder({
+            ...this.#props,
+            node: AlterTableNode.cloneWithTableProps(this.#props.node, {
+                addIndex: AddIndexNode.cloneWith(this.#props.node.addIndex, {
+                    using: RawNode.createWithSql(indexType),
+                }),
+            }),
+        });
+    }
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call(func) {
+        return func(this);
+    }
+    toOperationNode() {
+        return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
+    }
+    compile() {
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
+    }
+    async execute() {
+        await this.#props.executor.executeQuery(this.compile());
+    }
+}