@redocly/reef 0.133.0-next.0 → 0.133.0-next.2

package/dist/server/providers/database/client.d.ts

@@ -17,7 +17,7 @@ export declare class DatabaseClient {
     static init(config: Config, options?: DatabaseClientInitOptions): Promise<DatabaseClient>;
     migrate(prefix: string, suffix?: string): Promise<void>;
     close(): Promise<void>;
-    sync(): Promise<import("@libsql/client").Replicated>;
+    sync(): Promise<void>;
 }
 export {};
 //# sourceMappingURL=client.d.ts.map

package/dist/server/providers/database/client.js

@@ -1 +1 @@
-import e from"node:path";import{sql as s}from"drizzle-orm";import{drizzle as o}from"drizzle-orm/libsql";import{migrate as c}from"drizzle-orm/libsql/migrator";import{TransactionsManager as l}from"./transactions-manager.js";class r{dbClient;#t;constructor(t,i){this.dbClient=o(i(t)),this.#t=new l(this.dbClient)}get transactionsManager(){return this.#t}get client(){return this.#t.tx??this.dbClient}static async init(t,i){const{createClient:a}=await import("@libsql/client"),n=new r(t,a);return i?.runWithPragmaWalWriteOptimization&&await n.dbClient.run(s.raw("PRAGMA journal_mode = WAL;")),n}async migrate(t,i=""){await c(this.dbClient,{migrationsFolder:e.join(t,"migrations",i)})}async close(){this.dbClient.$client.close()}async sync(){return this.dbClient.$client.sync()}}export{r as DatabaseClient};
+import a from"node:path";import{sql as o}from"drizzle-orm";import{drizzle as c}from"drizzle-orm/libsql";import{migrate as l}from"drizzle-orm/libsql/migrator";import{TransactionsManager as m}from"./transactions-manager.js";class e{dbClient;#t;constructor(t,i){this.dbClient=c(i(t)),this.#t=new m(this.dbClient)}get transactionsManager(){return this.#t}get client(){return this.#t.tx??this.dbClient}static async init(t,i){const{createClient:s}=await import("@libsql/client"),r=new e(t,s);return i?.runWithPragmaWalWriteOptimization&&await r.dbClient.run(o.raw("PRAGMA journal_mode = WAL;")),r}async migrate(t,i=""){await l(this.dbClient,{migrationsFolder:a.join(t,"migrations",i)})}async close(){this.dbClient.$client.close()}async sync(){try{await this.dbClient.$client.sync()}catch(t){if(d(t))return;throw t}}}function d(n){if(!(n instanceof Error))return!1;const t=n.message.toLowerCase();return t.includes("syncnotsupported")&&(t.includes('("file")')||t.includes('"file"'))}export{e as DatabaseClient};

package/dist/server/providers/database/constants.d.ts

@@ -1,10 +1,5 @@
-export declare const CATALOG_LOCAL_DATABASE_NAME = "catalog-local.sqlite";
-export declare const CATALOG_LOCAL_DATABASE_FOLDER = "catalog-local";
-export declare const CATALOG_LOCAL_DATABASE_MIGRATIONS_FOLDER = "catalog-sqlite";
-export declare const MAIN_LOCAL_DATABASE_NAME = "main-local.sqlite";
-export declare const MAIN_LOCAL_DATABASE_FOLDER = "main-local";
-export declare const MAIN_LOCAL_DATABASE_MIGRATIONS_FOLDER = "main-sqlite";
-export declare const SQLD_REMOTE_DATABASE_NAME = "sqld-remote.sqlite";
-export declare const SQLD_REMOTE_DATABASE_FOLDER = "sqld-remote";
-export declare const SQLD_REMOTE_DATABASE_MIGRATIONS_FOLDER = "sqld-sqlite";
+export declare const SQLITE_DATABASE_NAME = "db.sqlite";
+export declare const SQLITE_DATABASE_MIGRATIONS_FOLDER = "sqlite-db";
+export declare const SQLITE_LOCAL_DATABASE_FOLDER = "local-sqlite-db";
+export declare const SQLITE_REMOTE_DATABASE_FOLDER = "remote-sqlite-db";
 //# sourceMappingURL=constants.d.ts.map

package/dist/server/providers/database/constants.js

@@ -1 +1 @@
-const A="catalog-local.sqlite",_="catalog-local",t="catalog-sqlite",o="main-local.sqlite",E="main-local",L="main-sqlite",O="sqld-remote.sqlite",l="sqld-remote",e="sqld-sqlite";export{_ as CATALOG_LOCAL_DATABASE_FOLDER,t as CATALOG_LOCAL_DATABASE_MIGRATIONS_FOLDER,A as CATALOG_LOCAL_DATABASE_NAME,E as MAIN_LOCAL_DATABASE_FOLDER,L as MAIN_LOCAL_DATABASE_MIGRATIONS_FOLDER,o as MAIN_LOCAL_DATABASE_NAME,l as SQLD_REMOTE_DATABASE_FOLDER,e as SQLD_REMOTE_DATABASE_MIGRATIONS_FOLDER,O as SQLD_REMOTE_DATABASE_NAME};
+const A="db.sqlite",E="sqlite-db",t="local-sqlite-db",_="remote-sqlite-db";export{E as SQLITE_DATABASE_MIGRATIONS_FOLDER,A as SQLITE_DATABASE_NAME,t as SQLITE_LOCAL_DATABASE_FOLDER,_ as SQLITE_REMOTE_DATABASE_FOLDER};

package/dist/server/providers/database/copy-migrations.js

@@ -1 +1 @@
-import c from"node:path";import{cpSync as m,existsSync as t,mkdirSync as l}from"node:fs";import{logger as i}from"../../tools/notifiers/logger.js";import{fromCurrentDir as d}from"../../utils/index.js";import{PACKAGE_NAME as f}from"../../../config/product-gates.js";const u=["@redocly/realm","@redocly/reef","@redocly/redoc-reef","@redocly/revel-reef"],D=r=>{if(!u.includes(f))return;const s=["catalog-sqlite","main-sqlite","sqld-sqlite"];for(const o of s){const e=d(import.meta.url,`./databases/${o}/migrations`),a=c.join(r.serverOutDir,"migrations",o);if(!t(e)){i.warn(`Migrations folder not found at ${e}`);continue}t(r.serverOutDir)||l(r.serverOutDir,{recursive:!0});try{m(e,a,{recursive:!0})}catch(n){i.error("Failed to copy migrations folder: %s",n)}}};export{D as copyMigrationsFolder};
+import a from"node:path";import{cpSync as c,existsSync as t,mkdirSync as m}from"node:fs";import{logger as i}from"../../tools/notifiers/logger.js";import{fromCurrentDir as d}from"../../utils/index.js";import{PACKAGE_NAME as f}from"../../../config/product-gates.js";const l=["@redocly/realm","@redocly/reef","@redocly/redoc-reef","@redocly/revel-reef"],A=r=>{if(!l.includes(f))return;const o="sqlite-db",e=d(import.meta.url,`./databases/${o}/migrations`),s=a.join(r.serverOutDir,"migrations",o);if(!t(e)){i.warn(`Migrations folder not found at ${e}`);return}t(r.serverOutDir)||m(r.serverOutDir,{recursive:!0});try{c(e,s,{recursive:!0})}catch(n){i.error("Failed to copy migrations folder: %s",n)}};export{A as copyMigrationsFolder};

package/dist/server/providers/database/database-connection-factory.d.ts

@@ -1,6 +1,6 @@
-import type { DatabaseConnection, DatabaseConnectionOptions, DatabaseName } from './types.js';
+import type { DatabaseConnection, DatabaseConnectionOptions } from './types.js';
 export declare class DatabaseConnectionFactory {
     #private;
-    static create(databaseName: DatabaseName, options: DatabaseConnectionOptions): Promise<DatabaseConnection | null>;
+    static create(options: DatabaseConnectionOptions): Promise<DatabaseConnection | null>;
 }
 //# sourceMappingURL=database-connection-factory.d.ts.map

package/dist/server/providers/database/database-connection-factory.js

@@ -1 +1 @@
-import{logger as i}from"../../tools/notifiers/logger.js";import{envConfig as e}from"../../config/env-config.js";import{CATALOG_LOCAL_DATABASE_FOLDER as A,CATALOG_LOCAL_DATABASE_MIGRATIONS_FOLDER as s,CATALOG_LOCAL_DATABASE_NAME as _,MAIN_LOCAL_DATABASE_FOLDER as l,MAIN_LOCAL_DATABASE_MIGRATIONS_FOLDER as c,MAIN_LOCAL_DATABASE_NAME as E,SQLD_REMOTE_DATABASE_FOLDER as D,SQLD_REMOTE_DATABASE_MIGRATIONS_FOLDER as T,SQLD_REMOTE_DATABASE_NAME as L}from"./constants.js";import{LocalDatabaseInitializationStrategy as o,RemoteDatabaseInitializationStrategy as d}from"./database-initialization-strategy.js";import{DatabaseConnectionsManager as m}from"./database-connections-manager.js";import{SQLD_REMOTE_DATABASE_URL_NO_DEPLOYMENT_YET_VAR as O}from"../../constants/plugins/catalog-entities.js";class N{static async create(a,t){switch(a){case"main-local":return await this.#a(t);case"catalog-local":return await this.#t(t);case"sqld-remote":return await this.#e(t);default:return null}}static async#a(a){return await new o().initialize({...a,databaseName:E,additionalFolder:l,migrationsFolder:c})}static async#t(a){return await new o().initialize({...a,databaseName:_,additionalFolder:A,migrationsFolder:s})}static async#e(a){try{const t=e.SQLD_REMOTE_DATABASE_URL||a.sqldRemoteDatabaseUrl,n=t===O?void 0:t,r=e.SQLD_REMOTE_DATABASE_AUTH_TOKEN||a.sqldRemoteDatabaseAuthToken;return(!n||!r)&&!e.isDevelopMode?(i.warn("Your remote database is not initialized yet, please wait for production deployment."),null):await m.getConnection({config:{...a,databaseName:L,additionalFolder:D,migrationsFolder:T,syncUrl:n,authToken:e.SQLD_REMOTE_DATABASE_AUTH_TOKEN||a.sqldRemoteDatabaseAuthToken},strategy:new d})}catch(t){return i.error("Remote database connection initialization failed",t),null}}}export{N as DatabaseConnectionFactory};
+import{logger as n}from"../../tools/notifiers/logger.js";import{envConfig as r}from"../../config/env-config.js";import{SQLITE_DATABASE_MIGRATIONS_FOLDER as o,SQLITE_LOCAL_DATABASE_FOLDER as c,SQLITE_REMOTE_DATABASE_FOLDER as l,SQLITE_DATABASE_NAME as i}from"./constants.js";import{DatabaseConnectionsManager as s}from"./database-connections-manager.js";import{SQLD_REMOTE_DATABASE_URL_NO_DEPLOYMENT_YET_VAR as T}from"../../constants/plugins/catalog-entities.js";class u{static async create(e){return this.#r(e)==="local"?await this.#t(e):await this.#a(e)}static async#t(e){return await s.getLocalConnection({...e,databaseName:i,additionalFolder:c,migrationsFolder:o})}static async#a(e){try{const{syncUrl:t,authToken:a}=this.#e(e);return!t||!a?(r.isDevelopMode||n.warn("Your remote database is not initialized yet, please wait for production deployment."),null):await s.getRemoteConnection({...e,databaseName:i,additionalFolder:l,migrationsFolder:o,syncUrl:t,authToken:a})}catch(t){return n.error("Remote database connection initialization failed",t),null}}static#r(e){if(e.databaseType)return e.databaseType;const{syncUrl:t,authToken:a}=this.#e(e);return t&&a?"remote":"local"}static#e(e){const t=r.SQLD_REMOTE_DATABASE_URL||e.sqldRemoteDatabaseUrl,a=r.SQLD_REMOTE_DATABASE_AUTH_TOKEN||e.sqldRemoteDatabaseAuthToken;return{syncUrl:this.#n(t),authToken:a}}static#n(e){return e===T?void 0:e}}export{u as DatabaseConnectionFactory};

package/dist/server/providers/database/database-connections-manager.d.ts

@@ -1,12 +1,7 @@
-import type { DatabaseConnectionInitOptions, DatabaseConnection } from './types.js';
-import { type DatabaseInitializationStrategy } from './database-initialization-strategy.js';
-type GetConnectionParams<TConfig extends DatabaseConnectionInitOptions> = {
-    config: TConfig;
-    strategy: DatabaseInitializationStrategy;
-};
+import type { DatabaseConnection, LocalDatabaseConnectionInitOptions, RemoteDatabaseConnectionInitOptions } from './types.js';
 export declare class DatabaseConnectionsManager {
     #private;
-    static getConnection<TConfig extends DatabaseConnectionInitOptions>({ config, strategy, }: GetConnectionParams<TConfig>): Promise<DatabaseConnection | null>;
+    static getLocalConnection(config: LocalDatabaseConnectionInitOptions): Promise<DatabaseConnection | null>;
+    static getRemoteConnection(config: RemoteDatabaseConnectionInitOptions): Promise<DatabaseConnection | null>;
 }
-export {};
 //# sourceMappingURL=database-connections-manager.d.ts.map

package/dist/server/providers/database/database-connections-manager.js

@@ -1 +1 @@
-import{logger as o}from"../../tools/notifiers/logger.js";const n="_redocly_db_preconnect_cache_";class t{static get#t(){const e=globalThis;if(!e[n]){const i={connections:new Map,pendingConnections:new Map,failedConnections:new Set};e[n]=i}return e[n]}static get#c(){return t.#t.connections}static get#e(){return t.#t.failedConnections}static get#i(){return t.#t.pendingConnections}static async getConnection({config:e,strategy:i}){const r=t.#l(e),c=t.#c.get(r);return c||t.#r({config:e,key:r,strategy:i})}static#r=async({config:e,key:i,strategy:r})=>{let c=t.#i.get(i);c||(t.#e.has(i)&&o.warn("Error connecting to the database, retrying..."),c=t.#n(e,i,r),t.#i.set(i,c));try{return await c}catch(l){return o.error("Error connecting to the database",l),t.#e.add(i),null}finally{t.#i.delete(i)}};static#n=async(e,i,r)=>{const c=await r.initialize(e);return t.#c.set(i,c),t.#e.delete(i),c};static#l=e=>`${e.baseDbDir}/${e.additionalFolder}/${e.databaseName}`}export{t as DatabaseConnectionsManager};
+import{logger as c}from"../../tools/notifiers/logger.js";import{SqldNotRunningError as y}from"./sqld-not-running-error.js";import{retryAsyncOperation as f}from"./utils/retry-async-operation.js";import{DatabasePathGenerator as h}from"./database-path-generator.js";import{DatabaseClient as w}from"./client.js";const m="_redocly_db_preconnect_cache_";class i{static get#t(){const t=globalThis;if(!t[m]){const n={connections:new Map,pendingConnections:new Map,failedConnections:new Set};t[m]=n}return t[m]}static get#i(){return i.#t.connections}static get#e(){return i.#t.failedConnections}static get#n(){return i.#t.pendingConnections}static async getLocalConnection(t){return i.#r(t,async()=>i.#a(t))}static async getRemoteConnection(t){return i.#r(t,async()=>i.#d(t))}static async#r(t,n){const e=i.#o(t),r=i.#i.get(e);if(r)if(r.client.dbClient.$client.closed)c.warn("Cached database client is closed. Reinitializing connection..."),i.#i.delete(e);else return r;return i.#l({key:e,initializer:n})}static#o=t=>{const n="syncUrl"in t&&typeof t.syncUrl=="string"?`|${t.syncUrl}`:"",e=t.additionalFolder??"";return`${t.baseDbDir}|${e}|${t.databaseName}${n}`};static async#l({key:t,initializer:n}){let e=i.#n.get(t);e||(i.#e.has(t)&&c.warn("Error connecting to the database, retrying..."),e=i.#s(t,n),i.#n.set(t,e));try{return await e}catch(r){return c.error("Error connecting to the database",r),i.#e.add(t),null}finally{i.#n.delete(t)}}static async#s(t,n){const e=await n();return i.#i.set(t,e),i.#e.delete(t),e}static async#a({removeExisting:t,baseDbDir:n,runWithPragmaWalWriteOptimization:e,databaseName:r,additionalFolder:a,migrationsFolder:d}){c.info("Initializing local database client...");const l=c.startTiming(),s=await i.#c({removeExisting:t,baseDbDir:n,databaseName:r,additionalFolder:a,migrationsFolder:d,runWithPragmaWalWriteOptimization:e});return c.infoTime(l,"Local database client initialized"),s}static async#d({removeExisting:t,baseDbDir:n,syncUrl:e,authToken:r,databaseName:a,additionalFolder:d,migrationsFolder:l}){c.info("Initializing remote database client...");const s=c.startTiming();return await f(async()=>{try{const o=await i.#c({removeExisting:t,baseDbDir:n,databaseName:a,additionalFolder:d,migrationsFolder:l,syncUrl:e,authToken:r});return c.infoTime(s,"Remote database client initialized"),o}catch(o){throw y.isSqldNotRunningError(o)?new y("SQLD server is not running yet, wait for production deployment",{cause:o}):o}},{maxRetries:3,retryStrategy:"exponential",delay:1e3,logger:c,messages:{retry:"Retrying remote database client initialization",maxRetriesReached:"Max retries reached, remote database client initialization failed"}})}static async#c({removeExisting:t,baseDbDir:n,databaseName:e,additionalFolder:r,migrationsFolder:a,runWithPragmaWalWriteOptimization:d,syncUrl:l,authToken:s}){const{databasePath:o}=await h.prepareDatabasePath({baseDir:n,databaseName:e,additionalFolder:r,removeExisting:t}),p=l&&s?{url:`file:${o}`,syncUrl:l,authToken:s}:{url:`file:${o}`},u=await w.init(p,{runWithPragmaWalWriteOptimization:d});return await u.migrate(n,a),{client:u,path:o}}}export{i as DatabaseConnectionsManager};

package/dist/server/providers/database/database-preconnect-service.js

@@ -1 +1 @@
-import{logger as o}from"../../tools/notifiers/logger.js";import{envConfig as n}from"../../config/env-config.js";import{DatabaseConnectionFactory as i}from"./database-connection-factory.js";class t{static#t=!1;static async init(e){if(!(n.REDOCLY_INTERNAL_DEV||n.CI)&&!t.#t)try{await t.#e(e)==="PRECONNECTED"&&(t.#t=!0)}catch(r){o.error("Failed to preconnect to sqld remote database",r)}}static#e=async e=>await i.create("sqld-remote",{baseDbDir:e})?(o.info("Sqld remote database preconnected"),"PRECONNECTED"):(o.warn("Sqld remote database preconnect failed"),"NOT_PRECONNECTED")}export{t as DatabasePreconnectService};
+import{logger as o}from"../../tools/notifiers/logger.js";import{envConfig as a}from"../../config/env-config.js";import{DatabaseConnectionFactory as i}from"./database-connection-factory.js";class t{static#t=!1;static async init(e){if(!(a.REDOCLY_INTERNAL_DEV||a.CI)&&!t.#t)try{await t.#e(e)==="PRECONNECTED"&&(t.#t=!0)}catch(r){o.error("Failed to preconnect to sqld remote database",r)}}static#e=async e=>await i.create({baseDbDir:e,databaseType:"remote"})?(o.info("Sqld remote database preconnected"),"PRECONNECTED"):(o.warn("Sqld remote database preconnect failed"),"NOT_PRECONNECTED")}export{t as DatabasePreconnectService};

package/dist/server/providers/database/databases/sqlite-db/drizzle.config.d.ts

@@ -0,0 +1,12 @@
+type DrizzleDbCredentials = {
+    url: string;
+    authToken?: string;
+};
+declare const _default: {
+    schema: string;
+    out: string;
+    dialect: "turso";
+    dbCredentials: DrizzleDbCredentials;
+};
+export default _default;
+//# sourceMappingURL=drizzle.config.d.ts.map

package/dist/server/providers/database/databases/sqlite-db/drizzle.config.js

@@ -0,0 +1 @@
+import{DatabasePathGenerator as a}from"../../database-path-generator";import{SQLITE_DATABASE_NAME as o,SQLITE_LOCAL_DATABASE_FOLDER as A}from"../../constants";const E="./dist/server/esbuild/cache/server",_="./src/server/providers/database/databases/sqlite-db/schemas/*",n="./src/server/providers/database/databases/sqlite-db/migrations",r="DRIZZLE_DB_TARGET",T=()=>process.env[r]==="remote"?"remote":"local",c=()=>`file:${a.generateDatabasePath({baseDir:E,databaseName:o,additionalFolder:A})}`,D=()=>{const s=T(),e=process.env.SQLD_REMOTE_DATABASE_URL,t=process.env.SQLD_REMOTE_DATABASE_AUTH_TOKEN;if(s==="remote"){if(!e||!t)throw new Error(`Remote DB selected (${r}=remote), but SQLD_REMOTE_DATABASE_URL or SQLD_REMOTE_DATABASE_AUTH_TOKEN is missing.`);return{url:e,authToken:t}}return{url:c()}};var S={schema:_,out:n,dialect:"turso",dbCredentials:D()};export{S as default};

package/dist/server/providers/database/databases/sqlite-db/migrations/0009_add-missing-local-tables.sql

@@ -0,0 +1,41 @@
+CREATE TABLE `cache` (
+	`key` text PRIMARY KEY NOT NULL,
+	`value` text DEFAULT '{}' NOT NULL,
+	`namespace` text NOT NULL,
+	`ttl` integer,
+	`created_at` text NOT NULL,
+	`updated_at` text NOT NULL
+);
+--> statement-breakpoint
+CREATE INDEX `idx_cache_namespace` ON `cache` (`namespace`);--> statement-breakpoint
+CREATE INDEX `idx_cache_key_namespace` ON `cache` (`key`,`namespace`);--> statement-breakpoint
+CREATE TABLE `file_hashes` (
+	`id` text PRIMARY KEY NOT NULL,
+	`file_type` text NOT NULL,
+	`file_path` text NOT NULL,
+	`hash` text NOT NULL,
+	`status` text DEFAULT 'upToDate' NOT NULL,
+	`created_at` text NOT NULL,
+	`updated_at` text NOT NULL
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `idx_file_hashes_type_path` ON `file_hashes` (`file_type`,`file_path`);--> statement-breakpoint
+CREATE INDEX `idx_file_hashes_type_hash` ON `file_hashes` (`file_type`,`hash`);--> statement-breakpoint
+CREATE TABLE `scorecards_config` (
+	`id` text PRIMARY KEY NOT NULL,
+	`key` text NOT NULL,
+	`slug` text NOT NULL,
+	`name` text NOT NULL,
+	`description` text,
+	`entities_filter` text NOT NULL,
+	`levels` text NOT NULL,
+	`config_hash` text NOT NULL,
+	`archived_at` text,
+	`created_at` text NOT NULL,
+	`updated_at` text NOT NULL
+);
+--> statement-breakpoint
+CREATE INDEX `idx_config_key` ON `scorecards_config` (`key`);--> statement-breakpoint
+CREATE INDEX `idx_config_slug` ON `scorecards_config` (`slug`);--> statement-breakpoint
+CREATE INDEX `idx_config_hash` ON `scorecards_config` (`config_hash`);--> statement-breakpoint
+CREATE INDEX `idx_config_archived` ON `scorecards_config` (`archived_at`);

package/dist/server/providers/database/databases/sqlite-db/migrations/0010_add-last-seen-run-id-to-entities-tables.sql

@@ -0,0 +1,4 @@
+ALTER TABLE `entities_relations` ADD `last_seen_run_id` text;--> statement-breakpoint
+CREATE INDEX `idx_entities_relations_source_file_last_seen_run_id` ON `entities_relations` (`source_file`,`last_seen_run_id`);--> statement-breakpoint
+ALTER TABLE `entities` ADD `last_seen_run_id` text;--> statement-breakpoint
+CREATE INDEX `idx_entities_source_last_seen_run_id` ON `entities` (`source`,`last_seen_run_id`);

package/dist/server/providers/database/databases/sqlite-db/migrations/0011_update-entities-relations-index.sql

@@ -0,0 +1,2 @@
+DROP INDEX `idx_entities_relations_source_file_last_seen_run_id`;--> statement-breakpoint
+CREATE INDEX `idx_entities_relations_last_seen_run_id_source_file` ON `entities_relations` (`last_seen_run_id`,`source_file`);