drizzle-kit 0.20.17-b08243d → 0.20.17-b2e8c7f

package/bin.cjs

@@ -8700,7 +8700,7 @@ var init_cli = __esm({
       authToken: stringType().optional(),
       introspectCasing: casing,
       breakpoints: booleanType().optional().default(true)
-    }).passthrough();
+    });
     configCheck = objectType({
       dialect: dialect3.optional(),
       out: stringType().optional()
@@ -99674,7 +99674,7 @@ __export(connections_exports, {
   connectToSQLite: () => connectToSQLite,
   preparePostgresDB: () => preparePostgresDB
 });
-var import_pg_core4, preparePostgresDB, parseMysqlCredentials, connectToMySQL, prepareSqliteParams, connectToSQLite;
+var preparePostgresDB, parseMysqlCredentials, connectToMySQL, prepareSqliteParams, connectToSQLite;
 var init_connections = __esm({
   "src/cli/connections.ts"() {
     "use strict";
@@ -99682,37 +99682,143 @@ var init_connections = __esm({
     init_utils2();
     init_global();
     init_outputs();
-    import_pg_core4 = require("drizzle-orm/pg-core");
     preparePostgresDB = async (credentials2) => {
       if ("driver" in credentials2) {
         if (credentials2.driver === "aws-data-api") {
+          let getValueFromDataApi2 = function(field) {
+            if (field.stringValue !== void 0) {
+              return field.stringValue;
+            } else if (field.booleanValue !== void 0) {
+              return field.booleanValue;
+            } else if (field.doubleValue !== void 0) {
+              return field.doubleValue;
+            } else if (field.isNull !== void 0) {
+              return null;
+            } else if (field.longValue !== void 0) {
+              return field.longValue;
+            } else if (field.blobValue !== void 0) {
+              return field.blobValue;
+            } else if (field.arrayValue !== void 0) {
+              if (field.arrayValue.stringValues !== void 0) {
+                return field.arrayValue.stringValues;
+              }
+              if (field.arrayValue.longValues !== void 0) {
+                return field.arrayValue.longValues;
+              }
+              if (field.arrayValue.doubleValues !== void 0) {
+                return field.arrayValue.doubleValues;
+              }
+              if (field.arrayValue.booleanValues !== void 0) {
+                return field.arrayValue.booleanValues;
+              }
+              if (field.arrayValue.arrayValues !== void 0) {
+                return field.arrayValue.arrayValues;
+              }
+              throw new Error("Unknown array type");
+            } else {
+              throw new Error("Unknown type");
+            }
+          }, typingsToAwsTypeHint2 = function(typings) {
+            if (typings === "date") {
+              return TypeHint.DATE;
+            } else if (typings === "decimal") {
+              return TypeHint.DECIMAL;
+            } else if (typings === "json") {
+              return TypeHint.JSON;
+            } else if (typings === "time") {
+              return TypeHint.TIME;
+            } else if (typings === "timestamp") {
+              return TypeHint.TIMESTAMP;
+            } else if (typings === "uuid") {
+              return TypeHint.UUID;
+            } else {
+              return void 0;
+            }
+          }, toValueParam2 = function(value, typings) {
+            const response = {
+              value: {},
+              typeHint: typingsToAwsTypeHint2(typings)
+            };
+            if (value === null) {
+              response.value = { isNull: true };
+            } else if (typeof value === "string") {
+              switch (response.typeHint) {
+                case TypeHint.DATE: {
+                  response.value = { stringValue: value.split("T")[0] };
+                  break;
+                }
+                case TypeHint.TIMESTAMP: {
+                  response.value = {
+                    stringValue: value.replace("T", " ").replace("Z", "")
+                  };
+                  break;
+                }
+                default: {
+                  response.value = { stringValue: value };
+                  break;
+                }
+              }
+            } else if (typeof value === "number" && Number.isInteger(value)) {
+              response.value = { longValue: value };
+            } else if (typeof value === "number" && !Number.isInteger(value)) {
+              response.value = { doubleValue: value };
+            } else if (typeof value === "boolean") {
+              response.value = { booleanValue: value };
+            } else if (value instanceof Date) {
+              response.value = {
+                stringValue: value.toISOString().replace("T", " ").replace("Z", "")
+              };
+            } else {
+              throw new Error(`Unknown type for ${value}`);
+            }
+            return response;
+          };
+          var getValueFromDataApi = getValueFromDataApi2, typingsToAwsTypeHint = typingsToAwsTypeHint2, toValueParam = toValueParam2;
           assertPackages("@aws-sdk/client-rds-data");
           const { RDSDataClient, ExecuteStatementCommand, TypeHint } = await Promise.resolve().then(() => __toESM(require_dist_cjs54()));
-          const { AwsDataApiSession } = await import("drizzle-orm/aws-data-api/pg");
           const rdsClient = new RDSDataClient();
-          const session = new AwsDataApiSession(
-            rdsClient,
-            new import_pg_core4.PgDialect(),
-            void 0,
-            {
-              database: credentials2.database,
-              resourceArn: credentials2.resourceArn,
-              secretArn: credentials2.secretArn
-            },
-            void 0
-          );
-          return {
-            async query(sql2, params) {
-              const prepared = session.prepareQuery({ sql: sql2, params: params ?? [] }, void 0, void 0, false);
-              const result = await prepared.execute();
-              return result;
-            },
-            async proxy(params) {
-              const prepared = session.prepareQuery({ sql: params.sql, params: params.params ?? [] }, void 0, void 0, params.mode === "array");
-              const result = await prepared.execute();
-              return result;
+          const query = async (sql2, params = []) => {
+            var _a;
+            const result = await rdsClient.send(
+              new ExecuteStatementCommand({
+                sql: sql2,
+                parameters: params.map((param, index4) => ({
+                  name: `${index4 + 1}`,
+                  ...toValueParam2(param, void 0)
+                })),
+                secretArn: credentials2.secretArn,
+                resourceArn: credentials2.resourceArn,
+                database: credentials2.database
+              })
+            );
+            const rows = ((_a = result.records) == null ? void 0 : _a.map((row) => {
+              return row.map((field) => getValueFromDataApi2(field));
+            })) ?? [];
+            return rows;
+          };
+          const proxy = async (params) => {
+            var _a;
+            const result = await rdsClient.send(
+              new ExecuteStatementCommand({
+                sql: params.sql,
+                parameters: params.params.map((param, index4) => ({
+                  name: `${index4 + 1}`,
+                  ...toValueParam2(param, void 0)
+                })),
+                secretArn: credentials2.secretArn,
+                resourceArn: credentials2.resourceArn,
+                database: credentials2.database
+              })
+            );
+            if (params.mode === "array") {
+              const rows = ((_a = result.records) == null ? void 0 : _a.map((row) => {
+                return row.map((field) => getValueFromDataApi2(field));
+              })) ?? [];
+              return rows;
             }
+            return result.records;
           };
+          return { query, proxy };
         }
         assertUnreachable(credentials2.driver);
       }
@@ -99994,7 +100100,7 @@ __export(studio_exports, {
   prepareSQLiteSchema: () => prepareSQLiteSchema,
   prepareServer: () => prepareServer
 });
-var import_node_https, import_pg_core5, import_drizzle_orm8, import_mysql_core4, import_sqlite_core3, preparePgSchema, prepareMySqlSchema, prepareSQLiteSchema, getCustomDefaults, drizzleForPostgres, drizzleForMySQL, drizzleForSQLite, init, proxySchema, defaultsSchema, schema4, jsonStringify, prepareServer;
+var import_node_https, import_pg_core4, import_drizzle_orm8, import_mysql_core4, import_sqlite_core3, preparePgSchema, prepareMySqlSchema, prepareSQLiteSchema, getCustomDefaults, drizzleForPostgres, drizzleForMySQL, drizzleForSQLite, init, proxySchema, defaultsSchema, schema4, jsonStringify, prepareServer;
 var init_studio = __esm({
   "src/serializer/studio.ts"() {
     "use strict";
@@ -100006,7 +100112,7 @@ var init_studio = __esm({
     init_dist5();
     init_lib();
     init_serializer();
-    import_pg_core5 = require("drizzle-orm/pg-core");
+    import_pg_core4 = require("drizzle-orm/pg-core");
     import_drizzle_orm8 = require("drizzle-orm");
     init_utils4();
     import_mysql_core4 = require("drizzle-orm/mysql-core");
@@ -100021,8 +100127,8 @@ var init_studio = __esm({
         const i0 = require(`${it}`);
         const i0values = Object.entries(i0);
         i0values.forEach(([k2, t]) => {
-          if ((0, import_drizzle_orm8.is)(t, import_pg_core5.PgTable)) {
-            const schema5 = (0, import_pg_core5.getTableConfig)(t).schema || "public";
+          if ((0, import_drizzle_orm8.is)(t, import_pg_core4.PgTable)) {
+            const schema5 = (0, import_pg_core4.getTableConfig)(t).schema || "public";
             pgSchema2[schema5] = pgSchema2[schema5] || {};
             pgSchema2[schema5][k2] = t;
           }
@@ -100087,8 +100193,8 @@ var init_studio = __esm({
       Object.entries(schema5).map(([schema6, tables]) => {
         Object.entries(tables).map(([, table4]) => {
           let tableConfig;
-          if ((0, import_drizzle_orm8.is)(table4, import_pg_core5.PgTable)) {
-            tableConfig = (0, import_pg_core5.getTableConfig)(table4);
+          if ((0, import_drizzle_orm8.is)(table4, import_pg_core4.PgTable)) {
+            tableConfig = (0, import_pg_core4.getTableConfig)(table4);
           } else if ((0, import_drizzle_orm8.is)(table4, import_mysql_core4.MySqlTable)) {
             tableConfig = (0, import_mysql_core4.getTableConfig)(table4);
           } else {

package/cli/validations/cli.d.ts

@@ -100,7 +100,7 @@ export declare const pullParams: import("zod").ZodObject<{
     authToken: import("zod").ZodOptional<import("zod").ZodString>;
     introspectCasing: import("zod").ZodDefault<import("zod").ZodUnion<[import("zod").ZodLiteral<"camel">, import("zod").ZodLiteral<"preserve">]>>;
     breakpoints: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
-}, "passthrough", import("zod").ZodTypeAny, {
+}, "strip", import("zod").ZodTypeAny, {
     dialect?: "mysql" | "postgresql" | "sqlite" | undefined;
     url?: string | undefined;
     host?: string | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drizzle-kit",
-  "version": "0.20.17-b08243d",
+  "version": "0.20.17-b2e8c7f",
   "repository": "https://github.com/drizzle-team/drizzle-kit-mirror",
   "author": "Drizzle Team",
   "license": "MIT",

package/payload.js

@@ -5550,7 +5550,7 @@ var init_cli = __esm({
       authToken: stringType().optional(),
       introspectCasing: casing,
       breakpoints: booleanType().optional().default(true)
-    }).passthrough();
+    });
     configCheck = objectType({
       dialect: dialect3.optional(),
       out: stringType().optional()

package/payload.mjs

@@ -5556,7 +5556,7 @@ var init_cli = __esm({
       authToken: stringType().optional(),
       introspectCasing: casing,
       breakpoints: booleanType().optional().default(true)
-    }).passthrough();
+    });
     configCheck = objectType({
       dialect: dialect3.optional(),
       out: stringType().optional()