@astrojs/db 0.0.0-10646-20240402132948

package/dist/_internal/core/types.d.ts

@@ -0,0 +1,59 @@
+import type { AstroIntegration } from 'astro';
+import type { z } from 'zod';
+import type { MaybeArray, booleanColumnSchema, columnSchema, columnsSchema, dateColumnSchema, dbConfigSchema, indexSchema, jsonColumnSchema, numberColumnOptsSchema, numberColumnSchema, referenceableColumnSchema, resolvedIndexSchema, tableSchema, textColumnOptsSchema, textColumnSchema } from './schemas.js';
+export type ResolvedIndexes = z.output<typeof dbConfigSchema>['tables'][string]['indexes'];
+export type BooleanColumn = z.infer<typeof booleanColumnSchema>;
+export type BooleanColumnInput = z.input<typeof booleanColumnSchema>;
+export type NumberColumn = z.infer<typeof numberColumnSchema>;
+export type NumberColumnInput = z.input<typeof numberColumnSchema>;
+export type TextColumn = z.infer<typeof textColumnSchema>;
+export type TextColumnInput = z.input<typeof textColumnSchema>;
+export type DateColumn = z.infer<typeof dateColumnSchema>;
+export type DateColumnInput = z.input<typeof dateColumnSchema>;
+export type JsonColumn = z.infer<typeof jsonColumnSchema>;
+export type JsonColumnInput = z.input<typeof jsonColumnSchema>;
+export type ColumnType = BooleanColumn['type'] | NumberColumn['type'] | TextColumn['type'] | DateColumn['type'] | JsonColumn['type'];
+export type DBColumn = z.infer<typeof columnSchema>;
+export type DBColumnInput = DateColumnInput | BooleanColumnInput | NumberColumnInput | TextColumnInput | JsonColumnInput;
+export type DBColumns = z.infer<typeof columnsSchema>;
+export type DBTable = z.infer<typeof tableSchema>;
+export type DBTables = Record<string, DBTable>;
+export type ResolvedDBTables = z.output<typeof dbConfigSchema>['tables'];
+export type ResolvedDBTable = z.output<typeof dbConfigSchema>['tables'][string];
+export type DBSnapshot = {
+    schema: Record<string, ResolvedDBTable>;
+    version: string;
+};
+export type DBConfigInput = z.input<typeof dbConfigSchema>;
+export type DBConfig = z.infer<typeof dbConfigSchema>;
+export type ColumnsConfig = z.input<typeof tableSchema>['columns'];
+export type OutputColumnsConfig = z.output<typeof tableSchema>['columns'];
+export interface TableConfig<TColumns extends ColumnsConfig = ColumnsConfig> extends Pick<z.input<typeof tableSchema>, 'columns' | 'indexes' | 'foreignKeys'> {
+    columns: TColumns;
+    foreignKeys?: Array<{
+        columns: MaybeArray<Extract<keyof TColumns, string>>;
+        references: () => MaybeArray<z.input<typeof referenceableColumnSchema>>;
+    }>;
+    indexes?: Array<IndexConfig<TColumns>> | Record<string, LegacyIndexConfig<TColumns>>;
+    deprecated?: boolean;
+}
+interface IndexConfig<TColumns extends ColumnsConfig> extends z.input<typeof indexSchema> {
+    on: MaybeArray<Extract<keyof TColumns, string>>;
+}
+/** @deprecated */
+interface LegacyIndexConfig<TColumns extends ColumnsConfig> extends z.input<typeof resolvedIndexSchema> {
+    on: MaybeArray<Extract<keyof TColumns, string>>;
+}
+export type NumberColumnOpts = z.input<typeof numberColumnOptsSchema>;
+export type TextColumnOpts = z.input<typeof textColumnOptsSchema>;
+export type AstroDbIntegration = AstroIntegration & {
+    hooks: {
+        'astro:db:setup'?: (options: {
+            extendDb: (options: {
+                configEntrypoint?: URL | string;
+                seedEntrypoint?: URL | string;
+            }) => void;
+        }) => void | Promise<void>;
+    };
+};
+export {};

package/dist/_internal/core/utils.d.ts

@@ -0,0 +1,20 @@
+import type { AstroConfig, AstroIntegration } from 'astro';
+import type { AstroDbIntegration } from './types.js';
+export type VitePlugin = Required<AstroConfig['vite']>['plugins'][number];
+export declare function getAstroStudioEnv(envMode?: string): Record<`ASTRO_STUDIO_${string}`, string>;
+export declare function getRemoteDatabaseUrl(): string;
+export declare function getAstroStudioUrl(): string;
+export declare function getDbDirectoryUrl(root: URL | string): URL;
+export declare function defineDbIntegration(integration: AstroDbIntegration): AstroIntegration;
+export type Result<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    data: unknown;
+};
+/**
+ * Map an object's values to a new set of values
+ * while preserving types.
+ */
+export declare function mapObject<T, U = T>(item: Record<string, T>, callback: (key: string, value: T) => U): Record<string, U>;

package/dist/_internal/runtime/config.d.ts

@@ -0,0 +1,154 @@
+import { LibsqlError } from '@libsql/client';
+import type { ColumnsConfig, DBConfigInput, TableConfig } from '../core/types.js';
+import type { LibSQLDatabase } from 'drizzle-orm/libsql';
+export type Database = Omit<LibSQLDatabase, 'transaction'>;
+export declare function isDbError(err: unknown): err is LibsqlError;
+export declare const column: {
+    number: <T extends ({
+        name?: string | undefined;
+        label?: string | undefined;
+        unique?: boolean | undefined;
+        deprecated?: boolean | undefined;
+        collection?: string | undefined;
+    } & ({
+        primaryKey?: false | undefined;
+        optional?: boolean | undefined;
+        default?: number | import("drizzle-orm").SQL<any> | undefined;
+    } | {
+        primaryKey: true;
+        optional?: false | undefined;
+        default?: undefined;
+    })) & {
+        references?: (() => {
+            type: "number";
+            schema: ({
+                name?: string | undefined;
+                label?: string | undefined;
+                unique?: boolean | undefined;
+                deprecated?: boolean | undefined;
+                collection?: string | undefined;
+            } & {
+                primaryKey?: false | undefined;
+                optional?: boolean | undefined;
+                default?: number | import("drizzle-orm").SQL<any> | undefined;
+            } & any) | ({
+                name?: string | undefined;
+                label?: string | undefined;
+                unique?: boolean | undefined;
+                deprecated?: boolean | undefined;
+                collection?: string | undefined;
+            } & {
+                primaryKey: true;
+                optional?: false | undefined;
+                default?: undefined;
+            } & any);
+        }) | undefined;
+    }>(opts?: T) => {
+        type: "number";
+        /**
+         * @internal
+         */
+        schema: T;
+    };
+    boolean: <T_1 extends {
+        name?: string | undefined;
+        label?: string | undefined;
+        optional?: boolean | undefined;
+        unique?: boolean | undefined;
+        deprecated?: boolean | undefined;
+        collection?: string | undefined;
+        default?: boolean | import("drizzle-orm").SQL<any> | undefined;
+    }>(opts?: T_1) => {
+        type: "boolean";
+        /**
+         * @internal
+         */
+        schema: T_1;
+    };
+    text: <T_2 extends ({
+        name?: string | undefined;
+        label?: string | undefined;
+        unique?: boolean | undefined;
+        deprecated?: boolean | undefined;
+        collection?: string | undefined;
+        default?: string | import("drizzle-orm").SQL<any> | undefined;
+        multiline?: boolean | undefined;
+    } & ({
+        primaryKey?: false | undefined;
+        optional?: boolean | undefined;
+    } | {
+        primaryKey: true;
+        optional?: false | undefined;
+    })) & {
+        references?: (() => {
+            type: "text";
+            schema: ({
+                name?: string | undefined;
+                label?: string | undefined;
+                unique?: boolean | undefined;
+                deprecated?: boolean | undefined;
+                collection?: string | undefined;
+                default?: string | import("drizzle-orm").SQL<any> | undefined;
+                multiline?: boolean | undefined;
+            } & {
+                primaryKey?: false | undefined;
+                optional?: boolean | undefined;
+            } & any) | ({
+                name?: string | undefined;
+                label?: string | undefined;
+                unique?: boolean | undefined;
+                deprecated?: boolean | undefined;
+                collection?: string | undefined;
+                default?: string | import("drizzle-orm").SQL<any> | undefined;
+                multiline?: boolean | undefined;
+            } & {
+                primaryKey: true;
+                optional?: false | undefined;
+            } & any);
+        }) | undefined;
+    }>(opts?: T_2) => {
+        type: "text";
+        /**
+         * @internal
+         */
+        schema: T_2;
+    };
+    date<T_3 extends {
+        name?: string | undefined;
+        label?: string | undefined;
+        optional?: boolean | undefined;
+        unique?: boolean | undefined;
+        deprecated?: boolean | undefined;
+        collection?: string | undefined;
+        default?: Date | import("drizzle-orm").SQL<any> | undefined;
+    }>(opts?: T_3): {
+        type: "date";
+        /**
+         * @internal
+         */
+        schema: T_3;
+    };
+    json<T_4 extends {
+        name?: string | undefined;
+        label?: string | undefined;
+        optional?: boolean | undefined;
+        unique?: boolean | undefined;
+        deprecated?: boolean | undefined;
+        collection?: string | undefined;
+        default?: unknown;
+    }>(opts?: T_4): {
+        type: "json";
+        /**
+         * @internal
+         */
+        schema: T_4;
+    };
+};
+export declare function defineTable<TColumns extends ColumnsConfig>(userConfig: TableConfig<TColumns>): TableConfig<TColumns>;
+export declare function defineDb(userConfig: DBConfigInput): {
+    tables?: unknown;
+};
+export declare const NOW: import("drizzle-orm").SQL<unknown>;
+export declare const TRUE: import("drizzle-orm").SQL<unknown>;
+export declare const FALSE: import("drizzle-orm").SQL<unknown>;
+export { sql, eq, gt, gte, lt, lte, ne, isNull, isNotNull, inArray, notInArray, exists, notExists, between, notBetween, like, notIlike, not, asc, desc, and, or, count, countDistinct, avg, avgDistinct, sum, sumDistinct, max, min, } from 'drizzle-orm';

package/dist/_internal/runtime/types.d.ts

@@ -0,0 +1,69 @@
+import type { ColumnBaseConfig, ColumnDataType } from 'drizzle-orm';
+import type { SQLiteColumn, SQLiteTableWithColumns } from 'drizzle-orm/sqlite-core';
+import type { ColumnsConfig, DBColumn, OutputColumnsConfig } from '../core/types.js';
+type GeneratedConfig<T extends ColumnDataType = ColumnDataType> = Pick<ColumnBaseConfig<T, string>, 'name' | 'tableName' | 'notNull' | 'hasDefault'>;
+export type AstroText<T extends GeneratedConfig<'string'>> = SQLiteColumn<T & {
+    data: string;
+    dataType: 'string';
+    columnType: 'SQLiteText';
+    driverParam: string;
+    enumValues: never;
+    baseColumn: never;
+}>;
+export type AstroDate<T extends GeneratedConfig<'custom'>> = SQLiteColumn<T & {
+    data: Date;
+    dataType: 'custom';
+    columnType: 'SQLiteCustomColumn';
+    driverParam: string;
+    enumValues: never;
+    baseColumn: never;
+}>;
+export type AstroBoolean<T extends GeneratedConfig<'boolean'>> = SQLiteColumn<T & {
+    data: boolean;
+    dataType: 'boolean';
+    columnType: 'SQLiteBoolean';
+    driverParam: number;
+    enumValues: never;
+    baseColumn: never;
+}>;
+export type AstroNumber<T extends GeneratedConfig<'number'>> = SQLiteColumn<T & {
+    data: number;
+    dataType: 'number';
+    columnType: 'SQLiteInteger';
+    driverParam: number;
+    enumValues: never;
+    baseColumn: never;
+}>;
+export type AstroJson<T extends GeneratedConfig<'custom'>> = SQLiteColumn<T & {
+    data: unknown;
+    dataType: 'custom';
+    columnType: 'SQLiteCustomColumn';
+    driverParam: string;
+    enumValues: never;
+    baseColumn: never;
+}>;
+export type Column<T extends DBColumn['type'], S extends GeneratedConfig> = T extends 'boolean' ? AstroBoolean<S> : T extends 'number' ? AstroNumber<S> : T extends 'text' ? AstroText<S> : T extends 'date' ? AstroDate<S> : T extends 'json' ? AstroJson<S> : never;
+export type Table<TTableName extends string, TColumns extends OutputColumnsConfig | ColumnsConfig> = SQLiteTableWithColumns<{
+    name: TTableName;
+    schema: undefined;
+    dialect: 'sqlite';
+    columns: {
+        [K in Extract<keyof TColumns, string>]: Column<TColumns[K]['type'], {
+            tableName: TTableName;
+            name: K;
+            hasDefault: TColumns[K]['schema'] extends {
+                default: NonNullable<unknown>;
+            } ? true : TColumns[K]['schema'] extends {
+                primaryKey: true;
+            } ? true : false;
+            notNull: TColumns[K]['schema']['optional'] extends true ? false : true;
+        }>;
+    };
+}>;
+export declare const SERIALIZED_SQL_KEY = "__serializedSQL";
+export type SerializedSQL = {
+    [SERIALIZED_SQL_KEY]: true;
+    sql: string;
+};
+export declare function isSerializedSQL(value: any): value is SerializedSQL;
+export {};

package/dist/core/cli/commands/execute/index.d.ts

@@ -0,0 +1,8 @@
+import type { AstroConfig } from 'astro';
+import type { Arguments } from 'yargs-parser';
+import { type DBConfig } from '../../../types.js';
+export declare function cmd({ astroConfig, dbConfig, flags, }: {
+    astroConfig: AstroConfig;
+    dbConfig: DBConfig;
+    flags: Arguments;
+}): Promise<void>;

package/dist/core/cli/commands/execute/index.js

@@ -0,0 +1,66 @@
+import { existsSync } from "node:fs";
+import { LibsqlError } from "@libsql/client";
+import { green } from "kleur/colors";
+import {
+  EXEC_DEFAULT_EXPORT_ERROR,
+  EXEC_ERROR,
+  FILE_NOT_FOUND_ERROR,
+  MISSING_EXECUTE_PATH_ERROR
+} from "../../../errors.js";
+import {
+  getLocalVirtualModContents,
+  getStudioVirtualModContents
+} from "../../../integration/vite-plugin-db.js";
+import { bundleFile, importBundledFile } from "../../../load-file.js";
+import { getManagedAppTokenOrExit } from "../../../tokens.js";
+import {} from "../../../types.js";
+async function cmd({
+  astroConfig,
+  dbConfig,
+  flags
+}) {
+  const filePath = flags._[4];
+  if (typeof filePath !== "string") {
+    console.error(MISSING_EXECUTE_PATH_ERROR);
+    process.exit(1);
+  }
+  const fileUrl = new URL(filePath, astroConfig.root);
+  if (!existsSync(fileUrl)) {
+    console.error(FILE_NOT_FOUND_ERROR(filePath));
+    process.exit(1);
+  }
+  let virtualModContents;
+  if (flags.remote) {
+    const appToken = await getManagedAppTokenOrExit(flags.token);
+    virtualModContents = getStudioVirtualModContents({
+      tables: dbConfig.tables ?? {},
+      appToken: appToken.token,
+      isBuild: false
+    });
+  } else {
+    virtualModContents = getLocalVirtualModContents({
+      tables: dbConfig.tables ?? {},
+      root: astroConfig.root,
+      shouldSeed: false,
+      seedFiles: []
+    });
+  }
+  const { code } = await bundleFile({ virtualModContents, root: astroConfig.root, fileUrl });
+  const mod = await importBundledFile({ code, root: astroConfig.root });
+  if (typeof mod.default !== "function") {
+    console.error(EXEC_DEFAULT_EXPORT_ERROR(filePath));
+    process.exit(1);
+  }
+  try {
+    await mod.default();
+    console.info(`${green("\u2714")} File run successfully.`);
+  } catch (e) {
+    if (e instanceof LibsqlError) {
+      throw new Error(EXEC_ERROR(e.message));
+    }
+    throw e;
+  }
+}
+export {
+  cmd
+};

package/dist/core/cli/commands/link/index.d.ts

@@ -0,0 +1,20 @@
+export declare function cmd(): Promise<void>;
+export declare function createNewProject({ workspaceId, name, region, }: {
+    workspaceId: string;
+    name: string;
+    region: string;
+}): Promise<{
+    id: string;
+    idName: string;
+}>;
+export declare function promptExistingProjectName({ workspaceId }: {
+    workspaceId: string;
+}): Promise<{
+    id: string;
+    idName: string;
+}>;
+export declare function promptBegin(): Promise<void>;
+export declare function promptLinkExisting(): Promise<boolean>;
+export declare function promptLinkNew(): Promise<boolean>;
+export declare function promptNewProjectName(): Promise<string>;
+export declare function promptNewProjectRegion(): Promise<string>;

package/dist/core/cli/commands/link/index.js

@@ -0,0 +1,252 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename } from "node:path";
+import { slug } from "github-slugger";
+import { bgRed, cyan } from "kleur/colors";
+import ora from "ora";
+import prompts from "prompts";
+import { safeFetch } from "../../../../runtime/utils.js";
+import { MISSING_SESSION_ID_ERROR } from "../../../errors.js";
+import { PROJECT_ID_FILE, getSessionIdFromFile } from "../../../tokens.js";
+import { getAstroStudioUrl } from "../../../utils.js";
+async function cmd() {
+  const sessionToken = await getSessionIdFromFile();
+  if (!sessionToken) {
+    console.error(MISSING_SESSION_ID_ERROR);
+    process.exit(1);
+  }
+  const getWorkspaceIdAsync = getWorkspaceId();
+  await promptBegin();
+  const isLinkExisting = await promptLinkExisting();
+  if (isLinkExisting) {
+    const workspaceId = await getWorkspaceIdAsync;
+    const existingProjectData = await promptExistingProjectName({ workspaceId });
+    return await linkProject(existingProjectData.id);
+  }
+  const isLinkNew = await promptLinkNew();
+  if (isLinkNew) {
+    const workspaceId = await getWorkspaceIdAsync;
+    const newProjectName = await promptNewProjectName();
+    const newProjectRegion = await promptNewProjectRegion();
+    const spinner = ora("Creating new project...").start();
+    const newProjectData = await createNewProject({
+      workspaceId,
+      name: newProjectName,
+      region: newProjectRegion
+    });
+    await new Promise((r) => setTimeout(r, 4e3));
+    spinner.succeed("Project created!");
+    return await linkProject(newProjectData.id);
+  }
+}
+async function linkProject(id) {
+  await mkdir(new URL(".", PROJECT_ID_FILE), { recursive: true });
+  await writeFile(PROJECT_ID_FILE, `${id}`);
+  console.info("Project linked.");
+}
+async function getWorkspaceId() {
+  const linkUrl = new URL(getAstroStudioUrl() + "/api/cli/workspaces.list");
+  const response = await safeFetch(
+    linkUrl,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${await getSessionIdFromFile()}`,
+        "Content-Type": "application/json"
+      }
+    },
+    (res) => {
+      if (res.status === 401) {
+        console.error(
+          `${bgRed("Unauthorized")}
+
+  Are you logged in?
+  Run ${cyan(
+            "astro db login"
+          )} to authenticate and then try linking again.
+
+`
+        );
+        process.exit(1);
+      }
+      console.error(`Failed to fetch user workspace: ${res.status} ${res.statusText}`);
+      process.exit(1);
+    }
+  );
+  const { data, success } = await response.json();
+  if (!success) {
+    console.error(`Failed to fetch user's workspace.`);
+    process.exit(1);
+  }
+  return data[0].id;
+}
+async function createNewProject({
+  workspaceId,
+  name,
+  region
+}) {
+  const linkUrl = new URL(getAstroStudioUrl() + "/api/cli/projects.create");
+  const response = await safeFetch(
+    linkUrl,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${await getSessionIdFromFile()}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ workspaceId, name, region })
+    },
+    (res) => {
+      if (res.status === 401) {
+        console.error(
+          `${bgRed("Unauthorized")}
+
+  Are you logged in?
+  Run ${cyan(
+            "astro db login"
+          )} to authenticate and then try linking again.
+
+`
+        );
+        process.exit(1);
+      }
+      console.error(`Failed to create project: ${res.status} ${res.statusText}`);
+      process.exit(1);
+    }
+  );
+  const { data, success } = await response.json();
+  if (!success) {
+    console.error(`Failed to create project.`);
+    process.exit(1);
+  }
+  return { id: data.id, idName: data.idName };
+}
+async function promptExistingProjectName({ workspaceId }) {
+  const linkUrl = new URL(getAstroStudioUrl() + "/api/cli/projects.list");
+  const response = await safeFetch(
+    linkUrl,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${await getSessionIdFromFile()}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ workspaceId })
+    },
+    (res) => {
+      if (res.status === 401) {
+        console.error(
+          `${bgRed("Unauthorized")}
+
+  Are you logged in?
+  Run ${cyan(
+            "astro db login"
+          )} to authenticate and then try linking again.
+
+`
+        );
+        process.exit(1);
+      }
+      console.error(`Failed to fetch projects: ${res.status} ${res.statusText}`);
+      process.exit(1);
+    }
+  );
+  const { data, success } = await response.json();
+  if (!success) {
+    console.error(`Failed to fetch projects.`);
+    process.exit(1);
+  }
+  const { projectId } = await prompts({
+    type: "autocomplete",
+    name: "projectId",
+    message: "What is your project name?",
+    limit: 5,
+    choices: data.map((p) => ({ title: p.name, value: p.id }))
+  });
+  if (typeof projectId !== "string") {
+    console.log("Canceled.");
+    process.exit(0);
+  }
+  const selectedProjectData = data.find((p) => p.id === projectId);
+  return selectedProjectData;
+}
+async function promptBegin() {
+  const prettyCwd = process.cwd().replace(homedir(), "~");
+  const { begin } = await prompts({
+    type: "confirm",
+    name: "begin",
+    message: `Link "${prettyCwd}" with Astro Studio?`,
+    initial: true
+  });
+  if (!begin) {
+    console.log("Canceled.");
+    process.exit(0);
+  }
+}
+async function promptLinkExisting() {
+  const { linkExisting } = await prompts({
+    type: "confirm",
+    name: "linkExisting",
+    message: `Link with an existing project in Astro Studio?`,
+    initial: true
+  });
+  return !!linkExisting;
+}
+async function promptLinkNew() {
+  const { linkNew } = await prompts({
+    type: "confirm",
+    name: "linkNew",
+    message: `Create a new project in Astro Studio?`,
+    initial: true
+  });
+  if (!linkNew) {
+    console.log("Canceled.");
+    process.exit(0);
+  }
+  return true;
+}
+async function promptNewProjectName() {
+  const { newProjectName } = await prompts({
+    type: "text",
+    name: "newProjectName",
+    message: `What is your new project's name?`,
+    initial: basename(process.cwd()),
+    format: (val) => slug(val)
+  });
+  if (!newProjectName) {
+    console.log("Canceled.");
+    process.exit(0);
+  }
+  return newProjectName;
+}
+async function promptNewProjectRegion() {
+  const { newProjectRegion } = await prompts({
+    type: "select",
+    name: "newProjectRegion",
+    message: `Where should your new database live?`,
+    choices: [
+      { title: "North America (East)", value: "NorthAmericaEast" },
+      { title: "North America (West)", value: "NorthAmericaWest" },
+      { title: "Europe (Amsterdam)", value: "EuropeCentral" },
+      { title: "South America (Brazil)", value: "SouthAmericaEast" },
+      { title: "Asia (India)", value: "AsiaSouth" },
+      { title: "Asia (Japan)", value: "AsiaNorthEast" }
+    ],
+    initial: 0
+  });
+  if (!newProjectRegion) {
+    console.log("Canceled.");
+    process.exit(0);
+  }
+  return newProjectRegion;
+}
+export {
+  cmd,
+  createNewProject,
+  promptBegin,
+  promptExistingProjectName,
+  promptLinkExisting,
+  promptLinkNew,
+  promptNewProjectName,
+  promptNewProjectRegion
+};

package/dist/core/cli/commands/login/index.d.ts

@@ -0,0 +1,8 @@
+import type { AstroConfig } from 'astro';
+import type { Arguments } from 'yargs-parser';
+import type { DBConfig } from '../../../types.js';
+export declare function cmd({ flags, }: {
+    astroConfig: AstroConfig;
+    dbConfig: DBConfig;
+    flags: Arguments;
+}): Promise<void>;