@decocms/mesh 2.20.0 → 2.20.2

package/dist/server/node_modules/kysely/dist/cjs/migration/migrator.js

@@ -58,7 +58,8 @@ class Migrator {
      * The returned array is sorted by migration name.
      */
     async getMigrations() {
-        const executedMigrations = (await this.#doesTableExists(this.#migrationTable))
+        const tableExists = await this.#doesTableExist(this.#migrationTable);
+        const executedMigrations = tableExists
             ? await this.#props.db
                 .withPlugin(this.#schemaPlugin)
                 .selectFrom(this.#migrationTable)
@@ -265,7 +266,10 @@ class Migrator {
     }
     async #migrate(getMigrationDirectionAndStep) {
         try {
-            await this.#ensureMigrationTablesExists();
+            await this.#ensureMigrationTableSchemaExists();
+            await this.#ensureMigrationTableExists();
+            await this.#ensureMigrationLockTableExists();
+            await this.#ensureLockRowExists();
             return await this.#runMigrations(getMigrationDirectionAndStep);
         }
         catch (error) {
@@ -293,95 +297,98 @@ class Migrator {
         }
         return new noop_plugin_js_1.NoopPlugin();
     }
-    async #ensureMigrationTablesExists() {
-        await this.#ensureMigrationTableSchemaExists();
-        await this.#ensureMigrationTableExists();
-        await this.#ensureMigrationLockTableExists();
-        await this.#ensureLockRowExists();
-    }
     async #ensureMigrationTableSchemaExists() {
         if (!this.#migrationTableSchema) {
             // Use default schema. Nothing to do.
             return;
         }
-        if (!(await this.#doesSchemaExists())) {
-            try {
-                await this.#createIfNotExists(this.#props.db.schema.createSchema(this.#migrationTableSchema));
-            }
-            catch (error) {
-                // At least on PostgreSQL, `if not exists` doesn't guarantee the `create schema`
-                // query doesn't throw if the schema already exits. That's why we check if
-                // the schema exist here and ignore the error if it does.
-                if (!(await this.#doesSchemaExists())) {
-                    throw error;
-                }
+        const schemaExists = await this.#doesSchemaExist();
+        if (schemaExists) {
+            return;
+        }
+        try {
+            await this.#createIfNotExists(this.#props.db.schema.createSchema(this.#migrationTableSchema));
+        }
+        catch (error) {
+            const schemaExists = await this.#doesSchemaExist();
+            // At least on PostgreSQL, `if not exists` doesn't guarantee the `create schema`
+            // query doesn't throw if the schema already exits. That's why we check if
+            // the schema exist here and ignore the error if it does.
+            if (!schemaExists) {
+                throw error;
             }
         }
     }
     async #ensureMigrationTableExists() {
-        if (!(await this.#doesTableExists(this.#migrationTable))) {
-            try {
-                if (this.#migrationTableSchema) {
-                    await this.#createIfNotExists(this.#props.db.schema.createSchema(this.#migrationTableSchema));
-                }
-                await this.#createIfNotExists(this.#props.db.schema
-                    .withPlugin(this.#schemaPlugin)
-                    .createTable(this.#migrationTable)
-                    .addColumn('name', 'varchar(255)', (col) => col.notNull().primaryKey())
-                    // The migration run time as ISO string. This is not a real date type as we
-                    // can't know which data type is supported by all future dialects.
-                    .addColumn('timestamp', 'varchar(255)', (col) => col.notNull()));
-            }
-            catch (error) {
-                // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
-                // query doesn't throw if the table already exits. That's why we check if
-                // the table exist here and ignore the error if it does.
-                if (!(await this.#doesTableExists(this.#migrationTable))) {
-                    throw error;
-                }
+        const tableExists = await this.#doesTableExist(this.#migrationTable);
+        if (tableExists) {
+            return;
+        }
+        try {
+            await this.#createIfNotExists(this.#props.db.schema
+                .withPlugin(this.#schemaPlugin)
+                .createTable(this.#migrationTable)
+                .addColumn('name', 'varchar(255)', (col) => col.notNull().primaryKey())
+                // The migration run time as ISO string. This is not a real date type as we
+                // can't know which data type is supported by all future dialects.
+                .addColumn('timestamp', 'varchar(255)', (col) => col.notNull()));
+        }
+        catch (error) {
+            const tableExists = await this.#doesTableExist(this.#migrationTable);
+            // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
+            // query doesn't throw if the table already exits. That's why we check if
+            // the table exist here and ignore the error if it does.
+            if (!tableExists) {
+                throw error;
             }
         }
     }
     async #ensureMigrationLockTableExists() {
-        if (!(await this.#doesTableExists(this.#migrationLockTable))) {
-            try {
-                await this.#createIfNotExists(this.#props.db.schema
-                    .withPlugin(this.#schemaPlugin)
-                    .createTable(this.#migrationLockTable)
-                    .addColumn('id', 'varchar(255)', (col) => col.notNull().primaryKey())
-                    .addColumn('is_locked', 'integer', (col) => col.notNull().defaultTo(0)));
-            }
-            catch (error) {
-                // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
-                // query doesn't throw if the table already exits. That's why we check if
-                // the table exist here and ignore the error if it does.
-                if (!(await this.#doesTableExists(this.#migrationLockTable))) {
-                    throw error;
-                }
+        const tableExists = await this.#doesTableExist(this.#migrationLockTable);
+        if (tableExists) {
+            return;
+        }
+        try {
+            await this.#createIfNotExists(this.#props.db.schema
+                .withPlugin(this.#schemaPlugin)
+                .createTable(this.#migrationLockTable)
+                .addColumn('id', 'varchar(255)', (col) => col.notNull().primaryKey())
+                .addColumn('is_locked', 'integer', (col) => col.notNull().defaultTo(0)));
+        }
+        catch (error) {
+            const tableExists = await this.#doesTableExist(this.#migrationLockTable);
+            // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
+            // query doesn't throw if the table already exits. That's why we check if
+            // the table exist here and ignore the error if it does.
+            if (!tableExists) {
+                throw error;
             }
         }
     }
     async #ensureLockRowExists() {
-        if (!(await this.#doesLockRowExists())) {
-            try {
-                await this.#props.db
-                    .withPlugin(this.#schemaPlugin)
-                    .insertInto(this.#migrationLockTable)
-                    .values({ id: exports.MIGRATION_LOCK_ID, is_locked: 0 })
-                    .execute();
-            }
-            catch (error) {
-                if (!(await this.#doesLockRowExists())) {
-                    throw error;
-                }
+        const lockRowExists = await this.#doesLockRowExists();
+        if (lockRowExists) {
+            return;
+        }
+        try {
+            await this.#props.db
+                .withPlugin(this.#schemaPlugin)
+                .insertInto(this.#migrationLockTable)
+                .values({ id: exports.MIGRATION_LOCK_ID, is_locked: 0 })
+                .execute();
+        }
+        catch (error) {
+            const lockRowExists = await this.#doesLockRowExists();
+            if (!lockRowExists) {
+                throw error;
             }
         }
     }
-    async #doesSchemaExists() {
+    async #doesSchemaExist() {
         const schemas = await this.#props.db.introspection.getSchemas();
         return schemas.some((it) => it.name === this.#migrationTableSchema);
     }
-    async #doesTableExists(tableName) {
+    async #doesTableExist(tableName) {
         const schema = this.#migrationTableSchema;
         const tables = await this.#props.db.introspection.getTables({
             withInternalKyselyTables: true,

package/dist/server/node_modules/kysely/dist/esm/index.d.ts

@@ -206,10 +206,11 @@ export * from './util/compilable.js';
 export * from './util/explainable.js';
 export * from './util/streamable.js';
 export * from './util/log.js';
-export type { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, Equals, UnknownRow, Simplify, SqlBool, Nullable, NumbersWhenDataTypeNotAvailable, NotNull, NumericString, ShallowDehydrateObject, ShallowDehydrateValue, StringsWhenDataTypeNotAvailable, } from './util/type-utils.js';
+export type { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, DrainOuterGeneric, Equals, ExtractColumnType, UnknownRow, Simplify, SqlBool, Nullable, NumbersWhenDataTypeNotAvailable, NotNull, NumericString, ShallowDehydrateObject, ShallowDehydrateValue, SimplifyResult, SimplifySingleResult, StringsWhenDataTypeNotAvailable, } from './util/type-utils.js';
 export * from './util/infer-result.js';
 export { logOnce } from './util/log-once.js';
 export { createQueryId, type QueryId } from './util/query-id.js';
+export type { KyselyTypeError } from './util/type-error.js';
 export type { SelectExpression, SelectCallback, SelectArg, Selection, CallbackSelection, } from './parser/select-parser.js';
 export type { ReferenceExpression, ReferenceExpressionOrList, SimpleReferenceExpression, StringReference, ExtractTypeFromStringReference, ExtractTypeFromReferenceExpression, } from './parser/reference-parser.js';
 export type { ValueExpression, ValueExpressionOrList, } from './parser/value-parser.js';
@@ -222,3 +223,4 @@ export type { ComparisonOperatorExpression, OperandValueExpression, OperandValue
 export type { ExistsExpression } from './parser/unary-operation-parser.js';
 export type { OperandExpression, ExpressionOrFactory, } from './parser/expression-parser.js';
 export type { Collation } from './parser/collate-parser.js';
+export type { QueryCreatorWithCommonTableExpression } from './parser/with-parser.js';

package/dist/server/node_modules/kysely/dist/esm/migration/migrator.d.ts

@@ -263,7 +263,7 @@ export interface MigratorProps {
      * the project, to the end of time or prepare to manually migrate the migration
      * tables.
      *
-     * This only works on postgres.
+     * This only works on postgres and mssql.
      */
     readonly migrationTableSchema?: string;
     /**

package/dist/server/node_modules/kysely/dist/esm/migration/migrator.js

@@ -56,7 +56,8 @@ export class Migrator {
      * The returned array is sorted by migration name.
      */
     async getMigrations() {
-        const executedMigrations = (await this.#doesTableExists(this.#migrationTable))
+        const tableExists = await this.#doesTableExist(this.#migrationTable);
+        const executedMigrations = tableExists
             ? await this.#props.db
                 .withPlugin(this.#schemaPlugin)
                 .selectFrom(this.#migrationTable)
@@ -263,7 +264,10 @@ export class Migrator {
     }
     async #migrate(getMigrationDirectionAndStep) {
         try {
-            await this.#ensureMigrationTablesExists();
+            await this.#ensureMigrationTableSchemaExists();
+            await this.#ensureMigrationTableExists();
+            await this.#ensureMigrationLockTableExists();
+            await this.#ensureLockRowExists();
             return await this.#runMigrations(getMigrationDirectionAndStep);
         }
         catch (error) {
@@ -291,95 +295,98 @@ export class Migrator {
         }
         return new NoopPlugin();
     }
-    async #ensureMigrationTablesExists() {
-        await this.#ensureMigrationTableSchemaExists();
-        await this.#ensureMigrationTableExists();
-        await this.#ensureMigrationLockTableExists();
-        await this.#ensureLockRowExists();
-    }
     async #ensureMigrationTableSchemaExists() {
         if (!this.#migrationTableSchema) {
             // Use default schema. Nothing to do.
             return;
         }
-        if (!(await this.#doesSchemaExists())) {
-            try {
-                await this.#createIfNotExists(this.#props.db.schema.createSchema(this.#migrationTableSchema));
-            }
-            catch (error) {
-                // At least on PostgreSQL, `if not exists` doesn't guarantee the `create schema`
-                // query doesn't throw if the schema already exits. That's why we check if
-                // the schema exist here and ignore the error if it does.
-                if (!(await this.#doesSchemaExists())) {
-                    throw error;
-                }
+        const schemaExists = await this.#doesSchemaExist();
+        if (schemaExists) {
+            return;
+        }
+        try {
+            await this.#createIfNotExists(this.#props.db.schema.createSchema(this.#migrationTableSchema));
+        }
+        catch (error) {
+            const schemaExists = await this.#doesSchemaExist();
+            // At least on PostgreSQL, `if not exists` doesn't guarantee the `create schema`
+            // query doesn't throw if the schema already exits. That's why we check if
+            // the schema exist here and ignore the error if it does.
+            if (!schemaExists) {
+                throw error;
             }
         }
     }
     async #ensureMigrationTableExists() {
-        if (!(await this.#doesTableExists(this.#migrationTable))) {
-            try {
-                if (this.#migrationTableSchema) {
-                    await this.#createIfNotExists(this.#props.db.schema.createSchema(this.#migrationTableSchema));
-                }
-                await this.#createIfNotExists(this.#props.db.schema
-                    .withPlugin(this.#schemaPlugin)
-                    .createTable(this.#migrationTable)
-                    .addColumn('name', 'varchar(255)', (col) => col.notNull().primaryKey())
-                    // The migration run time as ISO string. This is not a real date type as we
-                    // can't know which data type is supported by all future dialects.
-                    .addColumn('timestamp', 'varchar(255)', (col) => col.notNull()));
-            }
-            catch (error) {
-                // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
-                // query doesn't throw if the table already exits. That's why we check if
-                // the table exist here and ignore the error if it does.
-                if (!(await this.#doesTableExists(this.#migrationTable))) {
-                    throw error;
-                }
+        const tableExists = await this.#doesTableExist(this.#migrationTable);
+        if (tableExists) {
+            return;
+        }
+        try {
+            await this.#createIfNotExists(this.#props.db.schema
+                .withPlugin(this.#schemaPlugin)
+                .createTable(this.#migrationTable)
+                .addColumn('name', 'varchar(255)', (col) => col.notNull().primaryKey())
+                // The migration run time as ISO string. This is not a real date type as we
+                // can't know which data type is supported by all future dialects.
+                .addColumn('timestamp', 'varchar(255)', (col) => col.notNull()));
+        }
+        catch (error) {
+            const tableExists = await this.#doesTableExist(this.#migrationTable);
+            // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
+            // query doesn't throw if the table already exits. That's why we check if
+            // the table exist here and ignore the error if it does.
+            if (!tableExists) {
+                throw error;
             }
         }
     }
     async #ensureMigrationLockTableExists() {
-        if (!(await this.#doesTableExists(this.#migrationLockTable))) {
-            try {
-                await this.#createIfNotExists(this.#props.db.schema
-                    .withPlugin(this.#schemaPlugin)
-                    .createTable(this.#migrationLockTable)
-                    .addColumn('id', 'varchar(255)', (col) => col.notNull().primaryKey())
-                    .addColumn('is_locked', 'integer', (col) => col.notNull().defaultTo(0)));
-            }
-            catch (error) {
-                // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
-                // query doesn't throw if the table already exits. That's why we check if
-                // the table exist here and ignore the error if it does.
-                if (!(await this.#doesTableExists(this.#migrationLockTable))) {
-                    throw error;
-                }
+        const tableExists = await this.#doesTableExist(this.#migrationLockTable);
+        if (tableExists) {
+            return;
+        }
+        try {
+            await this.#createIfNotExists(this.#props.db.schema
+                .withPlugin(this.#schemaPlugin)
+                .createTable(this.#migrationLockTable)
+                .addColumn('id', 'varchar(255)', (col) => col.notNull().primaryKey())
+                .addColumn('is_locked', 'integer', (col) => col.notNull().defaultTo(0)));
+        }
+        catch (error) {
+            const tableExists = await this.#doesTableExist(this.#migrationLockTable);
+            // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
+            // query doesn't throw if the table already exits. That's why we check if
+            // the table exist here and ignore the error if it does.
+            if (!tableExists) {
+                throw error;
             }
         }
     }
     async #ensureLockRowExists() {
-        if (!(await this.#doesLockRowExists())) {
-            try {
-                await this.#props.db
-                    .withPlugin(this.#schemaPlugin)
-                    .insertInto(this.#migrationLockTable)
-                    .values({ id: MIGRATION_LOCK_ID, is_locked: 0 })
-                    .execute();
-            }
-            catch (error) {
-                if (!(await this.#doesLockRowExists())) {
-                    throw error;
-                }
+        const lockRowExists = await this.#doesLockRowExists();
+        if (lockRowExists) {
+            return;
+        }
+        try {
+            await this.#props.db
+                .withPlugin(this.#schemaPlugin)
+                .insertInto(this.#migrationLockTable)
+                .values({ id: MIGRATION_LOCK_ID, is_locked: 0 })
+                .execute();
+        }
+        catch (error) {
+            const lockRowExists = await this.#doesLockRowExists();
+            if (!lockRowExists) {
+                throw error;
             }
         }
     }
-    async #doesSchemaExists() {
+    async #doesSchemaExist() {
         const schemas = await this.#props.db.introspection.getSchemas();
         return schemas.some((it) => it.name === this.#migrationTableSchema);
     }
-    async #doesTableExists(tableName) {
+    async #doesTableExist(tableName) {
         const schema = this.#migrationTableSchema;
         const tables = await this.#props.db.introspection.getTables({
             withInternalKyselyTables: true,

package/dist/server/node_modules/kysely/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kysely",
-  "version": "0.28.9",
+  "version": "0.28.10",
   "description": "Type safe SQL query builder",
   "repository": {
     "type": "git",
@@ -76,35 +76,35 @@
   ],
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.2",
-    "@ark/attest": "^0.55.0",
+    "@ark/attest": "^0.56.0",
     "@types/better-sqlite3": "^7.6.13",
     "@types/chai": "^5.2.3",
     "@types/chai-as-promised": "^8.0.2",
     "@types/mocha": "^10.0.10",
     "@types/node": "^24.10.1",
-    "@types/pg": "^8.15.6",
+    "@types/pg": "^8.16.0",
     "@types/pg-cursor": "^2.7.2",
     "@types/semver": "^7.7.1",
-    "@types/sinon": "^17.0.4",
-    "better-sqlite3": "^12.5.0",
-    "chai": "^6.2.1",
+    "@types/sinon": "^21.0.0",
+    "better-sqlite3": "^12.6.0",
+    "chai": "^6.2.2",
     "chai-as-promised": "^8.0.2",
-    "esbuild": "^0.27.0",
+    "esbuild": "^0.27.2",
     "jsr": "^0.13.4",
     "lodash": "^4.17.21",
     "mocha": "^11.7.5",
-    "mysql2": "^3.15.3",
+    "mysql2": "^3.16.1",
     "pathe": "^2.0.3",
-    "pg": "^8.15.6",
-    "pg-cursor": "^2.14.6",
+    "pg": "^8.17.1",
+    "pg-cursor": "^2.16.1",
     "pkg-types": "^2.3.0",
     "playwright": "^1.57.0",
-    "prettier": "^3.7.3",
+    "prettier": "^3.8.0",
     "semver": "^7.7.3",
-    "sinon": "^21.0.0",
+    "sinon": "^21.0.1",
     "std-env": "^3.10.0",
     "tarn": "^3.0.2",
-    "tedious": "^19.1.3",
+    "tedious": "^19.2.0",
     "tsd": "^0.33.0",
     "typescript": "~5.9.3"
   },