rwsdk 0.1.16 → 0.1.17-test.20250715200658

package/dist/runtime/lib/db/typeInference/typetests/alterTable.typetest.js

@@ -0,0 +1,360 @@
+(_it = "alterTable addColumn") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("username", "text", (col) => col.notNull().unique())
+                        .execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .alterTable("users")
+                        .addColumn("displayName", "text")
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "alterTable renameColumn") => {
+    const migrations = {
+        "0001_initial": {
+            up: async (db) => [
+                await db.schema
+                    .createTable("users")
+                    .addColumn("id", "integer", (c) => c.primaryKey().autoIncrement())
+                    .addColumn("username", "text")
+                    .addColumn("displayName", "text")
+                    .execute(),
+            ],
+        },
+        "0002_rename_column": {
+            up: async (db) => [
+                await db.schema
+                    .alterTable("users")
+                    .renameColumn("displayName", "nickname")
+                    .execute(),
+            ],
+        },
+    };
+    (_test) => { };
+};
+(_it = "alterTable alterColumn setDataType and setDefault") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("age", "integer")
+                        .execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .alterTable("users")
+                        .alterColumn("age", (col) => col.setDataType("text"))
+                        .alterColumn("age", (col) => col.setDefault("unknown"))
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "alterTable alterColumn dropDefault, setNotNull, dropNotNull") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("age", "integer")
+                        .execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .alterTable("users")
+                        .alterColumn("age", (col) => col.dropDefault())
+                        .alterColumn("age", (col) => col.setNotNull())
+                        .alterColumn("age", (col) => col.dropNotNull())
+                        .execute(),
+                ];
+            },
+        },
+    };
+    //(_test: Expect<Equal<Actual, Expected>>) => {};
+};
+(_it = "alterTable addUniqueConstraint") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("firstName", "text")
+                        .addColumn("lastName", "text")
+                        .execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .alterTable("users")
+                        .addUniqueConstraint("unique_name", ["firstName", "lastName"])
+                        .execute(),
+                ];
+            },
+        },
+    };
+    //(_test: Expect<Equal<Actual, Expected>>) => {};
+};
+(_it = "alterTable drop column") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("age", "integer")
+                        .execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    await db.schema.alterTable("users").dropColumn("age").execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "alterTable renameTable") => {
+    const migrations = {
+        "0001_initial": {
+            up: async (db) => [
+                await db.schema
+                    .createTable("users")
+                    .addColumn("id", "integer")
+                    .execute(),
+            ],
+        },
+        "0002_rename_table": {
+            up: async (db) => [
+                await db.schema.alterTable("users").renameTo("customers").execute(),
+            ],
+        },
+    };
+    (_test) => { };
+};
+(_it = "alterTable renameColumn then rename again") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("name", "text")
+                        .execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .alterTable("users")
+                        .renameColumn("name", "firstName")
+                        .execute(),
+                ];
+            },
+        },
+        "2": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .alterTable("users")
+                        .renameColumn("firstName", "givenName")
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "alterTable renameColumn then rename back") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("name", "text")
+                        .execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .alterTable("users")
+                        .renameColumn("name", "firstName")
+                        .execute(),
+                ];
+            },
+        },
+        "2": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .alterTable("users")
+                        .renameColumn("firstName", "name")
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "alterTable renameTable then rename again") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("id", "integer")
+                        .execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    await db.schema.alterTable("users").renameTo("customers").execute(),
+                ];
+            },
+        },
+        "2": {
+            async up(db) {
+                return [
+                    await db.schema.alterTable("customers").renameTo("clients").execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "alterTable renameTable then rename back") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("id", "integer")
+                        .execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    await db.schema.alterTable("users").renameTo("customers").execute(),
+                ];
+            },
+        },
+        "2": {
+            async up(db) {
+                return [
+                    await db.schema.alterTable("customers").renameTo("users").execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "alterTable renameColumn then drop") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("name", "text")
+                        .execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .alterTable("users")
+                        .renameColumn("name", "firstName")
+                        .execute(),
+                ];
+            },
+        },
+        "2": {
+            async up(db) {
+                return [
+                    await db.schema.alterTable("users").dropColumn("firstName").execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "alterTable dropColumn then add back") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("name", "text")
+                        .execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    await db.schema.alterTable("users").dropColumn("name").execute(),
+                ];
+            },
+        },
+        "2": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .alterTable("users")
+                        .addColumn("name", "text")
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+export {};

package/dist/runtime/lib/db/typeInference/typetests/createTable.typetest.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/lib/db/typeInference/typetests/createTable.typetest.js

@@ -0,0 +1,33 @@
+(_it = "createTable") => {
+    const migrations = {
+        "001_init": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("username", "text", (col) => col.notNull().unique())
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "createTable with multiple columns and defaults") => {
+    const migrations = {
+        "001_init": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("username", "text", (col) => col.notNull())
+                        .addColumn("age", "integer", (col) => col.defaultTo(18))
+                        .addColumn("active", "boolean", (col) => col.defaultTo(true))
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+export {};

package/dist/runtime/lib/db/typeInference/typetests/dropTable.typetest.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/lib/db/typeInference/typetests/dropTable.typetest.js

@@ -0,0 +1,143 @@
+(_it = "dropTable") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("username", "text", (col) => col.notNull().unique())
+                        .execute(),
+                    await db.schema
+                        .createTable("posts")
+                        .addColumn("title", "text")
+                        .execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [await db.schema.dropTable("posts").execute()];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "dropTable non-existent table") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [await db.schema.dropTable("ghost").execute()];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "dropTable all tables") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema.createTable("a").addColumn("x", "text").execute(),
+                    await db.schema.createTable("b").addColumn("y", "text").execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    await db.schema.dropTable("a").execute(),
+                    await db.schema.dropTable("b").execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "chaining createTable and dropTable") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("username", "text")
+                        .execute(),
+                    await db.schema
+                        .createTable("posts")
+                        .addColumn("title", "text")
+                        .execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    await db.schema.dropTable("posts").execute(),
+                    await db.schema
+                        .createTable("comments")
+                        .addColumn("text", "text")
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "drop table then add it back") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("username", "text")
+                        .execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [await db.schema.dropTable("users").execute()];
+            },
+        },
+        "2": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("username", "text")
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+(_it = "rename table then drop it") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("username", "text")
+                        .execute(),
+                ];
+            },
+        },
+        "1": {
+            async up(db) {
+                return [
+                    await db.schema.alterTable("users").renameTo("customers").execute(),
+                ];
+            },
+        },
+        "2": {
+            async up(db) {
+                return [await db.schema.dropTable("customers").execute()];
+            },
+        },
+    };
+    (_test) => { };
+};
+export {};

package/dist/runtime/lib/db/typeInference/typetests/print.d.ts

@@ -0,0 +1,3 @@
+export type PrintType<T> = T extends infer U ? {
+    [K in keyof U]: U[K];
+} : never;

package/dist/runtime/lib/db/typeInference/typetests/print.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/lib/db/typeInference/typetests/testUtils.d.ts

@@ -0,0 +1,2 @@
+export type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
+export type Expect<T extends true> = T;

package/dist/runtime/lib/db/typeInference/typetests/testUtils.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/lib/db/typeInference/typetests/typeInference.typetest.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/lib/db/typeInference/typetests/typeInference.typetest.js

@@ -0,0 +1,17 @@
+(_it = "addColumn with default value") => {
+    const migrations = {
+        "0": {
+            async up(db) {
+                return [
+                    await db.schema
+                        .createTable("users")
+                        .addColumn("username", "text", (col) => col.notNull().unique())
+                        .addColumn("posts", "integer", (col) => col.defaultTo(0).notNull())
+                        .execute(),
+                ];
+            },
+        },
+    };
+    (_test) => { };
+};
+export {};

package/dist/runtime/lib/db/typeInference/utils.d.ts

@@ -0,0 +1,82 @@
+import { sql } from "kysely";
+type DataTypeExpression = string | typeof sql;
+export type AddColumnOp<K extends string, T extends DataTypeExpression> = {
+    op: "addColumn";
+    name: K;
+    type: T;
+};
+export type DropColumnOp<K extends string> = {
+    op: "dropColumn";
+    name: K;
+};
+export type RenameColumnOp<KFrom extends string, KTo extends string> = {
+    op: "renameColumn";
+    from: KFrom;
+    to: KTo;
+};
+export type ModifyColumnOp<K extends string, T extends DataTypeExpression> = {
+    op: "modifyColumn";
+    name: K;
+    type: T;
+};
+export type Alteration = {
+    kind: "setDataType";
+    dataType: string;
+} | {
+    kind: "setDefault";
+    value: any;
+} | {
+    kind: "dropDefault";
+} | {
+    kind: "setNotNull";
+} | {
+    kind: "dropNotNull";
+};
+export type AlterColumnOp<K extends string, TAlteration extends Alteration> = {
+    op: "alterColumn";
+    name: K;
+    alteration: TAlteration;
+};
+export type AlterOperation = AddColumnOp<any, any> | DropColumnOp<any> | RenameColumnOp<any, any> | AlterColumnOp<any, any> | ModifyColumnOp<any, any>;
+export type SqlToTsType<T extends string | typeof sql> = T extends "text" ? string : T extends "integer" ? number : T extends "blob" ? Uint8Array : T extends "real" ? number : T extends "boolean" ? boolean : T extends typeof sql ? any : never;
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type ExecutedBuilder<T> = {
+    __builder_type: T;
+};
+export type MergeSchemas<A, B> = Prettify<Omit<A, keyof B> & B>;
+export type OmitNever<T> = {
+    [K in keyof T as T[K] extends never ? never : K]: T[K];
+};
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export type DeepClean<T> = T extends Uint8Array ? T : T extends Record<string, any> ? {
+    [K in keyof T as T[K] extends never ? never : K]: DeepClean<T[K]>;
+} & {} : T;
+export type Cast<A, B> = A extends B ? A : B;
+/**
+ * Applies a single alteration operation to a schema.
+ */
+type ApplyOp<TSchema, THeadOp> = THeadOp extends AddColumnOp<infer K, infer T> ? Prettify<TSchema & {
+    [P in K]: SqlToTsType<T>;
+}> : THeadOp extends DropColumnOp<infer K> ? Omit<TSchema, K> : THeadOp extends RenameColumnOp<infer KFrom, infer KTo> ? KFrom extends keyof TSchema ? Prettify<Omit<TSchema, KFrom> & {
+    [P in KTo]: TSchema[KFrom];
+}> : TSchema : THeadOp extends AlterColumnOp<infer K, infer TAlt> ? TAlt extends {
+    kind: "setDataType";
+    dataType: infer DT extends string;
+} ? Prettify<Omit<TSchema, K> & {
+    [P in K]: SqlToTsType<DT>;
+}> : TSchema : THeadOp extends ModifyColumnOp<infer K, infer T> ? Prettify<Omit<TSchema, K> & {
+    [P in K]: SqlToTsType<T>;
+}> : TSchema;
+/**
+ * Recursively processes a list of alteration operations (AST)
+ * to transform an initial schema into the final schema.
+ */
+export type ProcessAlteredTable<TInitialSchema, TOps> = TOps extends [
+    infer THeadOp,
+    ...infer TRestOps
+] ? ProcessAlteredTable<ApplyOp<TInitialSchema, THeadOp>, TRestOps> : TInitialSchema;
+type LastOf<U> = UnionToIntersection<U extends any ? () => U : never> extends () => infer R ? R : never;
+export type UnionToTuple<U, Last = LastOf<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, Last>>, Last];
+export {};

package/dist/runtime/lib/db/typeInference/utils.js

@@ -0,0 +1,2 @@
+export {};
+// --- End Union to Tuple Helpers ---

package/dist/runtime/lib/debug.d.ts

@@ -0,0 +1,2 @@
+declare const debug: (namespace: string) => (...args: any[]) => void;
+export default debug;