kysely 0.19.7 → 0.19.10

package/dist/cjs/schema/schema.js

@@ -22,6 +22,10 @@ const create_view_builder_js_1 = require("./create-view-builder.js");
 const create_view_node_js_1 = require("../operation-node/create-view-node.js");
 const drop_view_builder_js_1 = require("./drop-view-builder.js");
 const drop_view_node_js_1 = require("../operation-node/drop-view-node.js");
+const create_type_builder_js_1 = require("./create-type-builder.js");
+const drop_type_builder_js_1 = require("./drop-type-builder.js");
+const create_type_node_js_1 = require("../operation-node/create-type-node.js");
+const drop_type_node_js_1 = require("../operation-node/drop-type-node.js");
 /**
  * Provides methods for building database schema.
  */
@@ -239,6 +243,48 @@ class SchemaModule {
             dropViewNode: drop_view_node_js_1.DropViewNode.create(viewName),
         });
     }
+    /**
+     * Create a new type.
+     *
+     * Only some dialects like PostgreSQL have user-defined types.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *   .createType('species')
+     *   .asEnum(['dog', 'cat', 'frog'])
+     *   .execute()
+     * ```
+     */
+    createType(viewName) {
+        return new create_type_builder_js_1.CreateTypeBuilder({
+            queryId: (0, query_id_js_1.createQueryId)(),
+            executor: this.#executor,
+            createTypeNode: create_type_node_js_1.CreateTypeNode.create(viewName),
+        });
+    }
+    /**
+     * Drop a type.
+     *
+     * Only some dialects like PostgreSQL have user-defined types.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *   .dropType('species')
+     *   .ifExists()
+     *   .execute()
+     * ```
+     */
+    dropType(viewName) {
+        return new drop_type_builder_js_1.DropTypeBuilder({
+            queryId: (0, query_id_js_1.createQueryId)(),
+            executor: this.#executor,
+            dropTypeNode: drop_type_node_js_1.DropTypeNode.create(viewName),
+        });
+    }
     /**
      * Returns a copy of this schema module with the given plugin installed.
      */

package/dist/cjs/util/require-all-props.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Utility type to force use of all properties of T.
+ *
+ * Similar to Required<T> build-in type, but allows `undefined` values.
+ */
+declare type AllProps<T> = T & {
+    [P in keyof T]-?: unknown;
+};
+/**
+ * Helper function to check listed properties according to given type. Check if all properties has been used when object is initialised.
+ *
+ * Example use:
+ *
+ * ```ts
+ * type SomeType = { propA: string; propB?: number; }
+ *
+ * // propB has to be mentioned even it is optional. It still should be initialized with undefined.
+ * const a: SomeType = requireAllProps<SomeType>({ propA: "value A", propB: undefined });
+ *
+ * // checked type is implicit for variable.
+ * const b = requireAllProps<SomeType>({ propA: "value A", propB: undefined });
+ * ```
+ *
+ * Wrong use of this helper:
+ *
+ * 1. Omit checked type - all checked properties will be expect as of type never
+ *
+ * ```ts
+ * const z: SomeType = requireAllProps({ propC: "no type will work" });
+ * ```
+ *
+ * 2. Apply to spreaded object - there is no way how to check in compile time if spreaded object contains all properties
+ *
+ * ```ts
+ * const y: SomeType = { propA: "" }; // valid object according to SomeType declaration
+ * const x = requireAllProps<SomeType>( { ... y } );
+ * ```
+ *
+ * @param obj object to check if all properties has been used
+ * @returns untouched obj parameter is returned
+ */
+export declare function requireAllProps<T>(obj: AllProps<T>): T;
+export {};

package/dist/cjs/util/require-all-props.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireAllProps = void 0;
+/**
+ * Helper function to check listed properties according to given type. Check if all properties has been used when object is initialised.
+ *
+ * Example use:
+ *
+ * ```ts
+ * type SomeType = { propA: string; propB?: number; }
+ *
+ * // propB has to be mentioned even it is optional. It still should be initialized with undefined.
+ * const a: SomeType = requireAllProps<SomeType>({ propA: "value A", propB: undefined });
+ *
+ * // checked type is implicit for variable.
+ * const b = requireAllProps<SomeType>({ propA: "value A", propB: undefined });
+ * ```
+ *
+ * Wrong use of this helper:
+ *
+ * 1. Omit checked type - all checked properties will be expect as of type never
+ *
+ * ```ts
+ * const z: SomeType = requireAllProps({ propC: "no type will work" });
+ * ```
+ *
+ * 2. Apply to spreaded object - there is no way how to check in compile time if spreaded object contains all properties
+ *
+ * ```ts
+ * const y: SomeType = { propA: "" }; // valid object according to SomeType declaration
+ * const x = requireAllProps<SomeType>( { ... y } );
+ * ```
+ *
+ * @param obj object to check if all properties has been used
+ * @returns untouched obj parameter is returned
+ */
+function requireAllProps(obj) {
+    return obj;
+}
+exports.requireAllProps = requireAllProps;

package/dist/esm/dialect/sqlite/sqlite-introspector.js

@@ -56,7 +56,7 @@ export class SqliteIntrospector {
                 dataType: col.type,
                 isNullable: !col.notnull,
                 isAutoIncrementing: col.name === autoIncrementCol,
-                hasDefaultValue: !!col.dflt_value,
+                hasDefaultValue: col.dflt_value != null,
             })),
         };
     }

package/dist/esm/operation-node/create-type-node.d.ts

@@ -0,0 +1,17 @@
+import { IdentifierNode } from './identifier-node.js';
+import { OperationNode } from './operation-node.js';
+import { ValueListNode } from './value-list-node.js';
+export declare type CreateTypeNodeParams = Omit<Partial<CreateTypeNode>, 'kind'>;
+export interface CreateTypeNode extends OperationNode {
+    readonly kind: 'CreateTypeNode';
+    readonly name: IdentifierNode;
+    readonly enum?: ValueListNode;
+}
+/**
+ * @internal
+ */
+export declare const CreateTypeNode: Readonly<{
+    is(node: OperationNode): node is CreateTypeNode;
+    create(name: string): CreateTypeNode;
+    cloneWithEnum(createType: CreateTypeNode, values: string[]): CreateTypeNode;
+}>;

package/dist/esm/operation-node/create-type-node.js

@@ -0,0 +1,25 @@
+/// <reference types="./create-type-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { IdentifierNode } from './identifier-node.js';
+import { ValueListNode } from './value-list-node.js';
+import { ValueNode } from './value-node.js';
+/**
+ * @internal
+ */
+export const CreateTypeNode = freeze({
+    is(node) {
+        return node.kind === 'CreateTypeNode';
+    },
+    create(name) {
+        return freeze({
+            kind: 'CreateTypeNode',
+            name: IdentifierNode.create(name),
+        });
+    },
+    cloneWithEnum(createType, values) {
+        return freeze({
+            ...createType,
+            enum: ValueListNode.create(values.map((value) => ValueNode.createImmediate(value))),
+        });
+    },
+});

package/dist/esm/operation-node/drop-type-node.d.ts

@@ -0,0 +1,16 @@
+import { IdentifierNode } from './identifier-node.js';
+import { OperationNode } from './operation-node.js';
+export declare type DropTypeNodeParams = Omit<Partial<DropTypeNode>, 'kind' | 'name'>;
+export interface DropTypeNode extends OperationNode {
+    readonly kind: 'DropTypeNode';
+    readonly name: IdentifierNode;
+    readonly ifExists?: boolean;
+}
+/**
+ * @internal
+ */
+export declare const DropTypeNode: Readonly<{
+    is(node: OperationNode): node is DropTypeNode;
+    create(name: string): DropTypeNode;
+    cloneWith(dropType: DropTypeNode, params: DropTypeNodeParams): DropTypeNode;
+}>;

package/dist/esm/operation-node/drop-type-node.js

@@ -0,0 +1,23 @@
+/// <reference types="./drop-type-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { IdentifierNode } from './identifier-node.js';
+/**
+ * @internal
+ */
+export const DropTypeNode = freeze({
+    is(node) {
+        return node.kind === 'DropTypeNode';
+    },
+    create(name) {
+        return freeze({
+            kind: 'DropTypeNode',
+            name: IdentifierNode.create(name),
+        });
+    },
+    cloneWith(dropType, params) {
+        return freeze({
+            ...dropType,
+            ...params,
+        });
+    },
+});

package/dist/esm/operation-node/operation-node-transformer.d.ts

@@ -65,6 +65,9 @@ import { GeneratedNode } from './generated-node.js';
 import { DefaultValueNode } from './default-value-node.js';
 import { OnNode } from './on-node.js';
 import { ValuesNode } from './values-node.js';
+import { SelectModifierNode } from './select-modifier-node.js';
+import { CreateTypeNode } from './create-type-node.js';
+import { DropTypeNode } from './drop-type-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -97,8 +100,9 @@ import { ValuesNode } from './values-node.js';
 export declare class OperationNodeTransformer {
     #private;
     protected readonly nodeStack: OperationNode[];
-    readonly transformNode: <T extends OperationNode | undefined>(node: OperationNode | undefined) => T;
-    protected transformNodeList<T extends OperationNode>(list: readonly T[] | undefined): readonly T[];
+    readonly transformNode: <T extends OperationNode | undefined, U extends T | undefined = T>(node: U) => T;
+    protected transformNodeList<T extends OperationNode, U extends T = T>(list: readonly U[]): readonly T[];
+    protected transformNodeList<T extends OperationNode, U extends T = T>(list: readonly U[] | undefined): readonly T[] | undefined;
     protected transformSelectQuery(node: SelectQueryNode): SelectQueryNode;
     protected transformSelection(node: SelectionNode): SelectionNode;
     protected transformColumn(node: ColumnNode): ColumnNode;
@@ -159,6 +163,9 @@ export declare class OperationNodeTransformer {
     protected transformGenerated(node: GeneratedNode): GeneratedNode;
     protected transformDefaultValue(node: DefaultValueNode): DefaultValueNode;
     protected transformOn(node: OnNode): OnNode;
+    protected transformSelectModifier(node: SelectModifierNode): SelectModifierNode;
+    protected transformCreateType(node: CreateTypeNode): CreateTypeNode;
+    protected transformDropType(node: DropTypeNode): DropTypeNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;