@astrojs/db 0.7.2 → 0.8.1

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

@@ -0,0 +1,55 @@
+import type { AstroIntegration } from 'astro';
+import type { z } from 'zod';
+import type { MaybeArray, booleanColumnSchema, columnSchema, columnsSchema, dateColumnSchema, dbConfigSchema, indexSchema, jsonColumnSchema, numberColumnOptsSchema, numberColumnSchema, referenceableColumnSchema, tableSchema, textColumnOptsSchema, textColumnSchema } from './schemas.js';
+export type Indexes = Record<string, z.infer<typeof indexSchema>>;
+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 DBSnapshot = {
+    schema: Record<string, DBTable>;
+    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?: Record<string, IndexConfig<TColumns>>;
+    deprecated?: boolean;
+}
+interface IndexConfig<TColumns extends ColumnsConfig> extends z.input<typeof indexSchema> {
+    on: MaybeArray<Extract<keyof TColumns, string>>;
+}
+/** @deprecated Use `TableConfig` instead */
+export type ResolvedCollectionConfig<TColumns extends ColumnsConfig = ColumnsConfig> = TableConfig<TColumns>;
+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/runtime/config.d.ts

@@ -0,0 +1,148 @@
+import type { ColumnsConfig, DBConfigInput, TableConfig } from '../core/types.js';
+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 { NOW, TRUE, FALSE } from './index.js';
+export { sql, eq, gt, gte, lt, lte, ne, isNull, isNotNull, inArray, notInArray, exists, notExists, between, notBetween, like, notIlike, not, asc, desc, and, or, } from 'drizzle-orm';

package/dist/_internal/runtime/db-client.d.ts

@@ -0,0 +1,5 @@
+import type { LibSQLDatabase } from 'drizzle-orm/libsql';
+export declare function createLocalDatabaseClient({ dbUrl }: {
+    dbUrl: string;
+}): LibSQLDatabase;
+export declare function createRemoteDatabaseClient(appToken: string, remoteDbURL: string): import("drizzle-orm/sqlite-proxy").SqliteRemoteDatabase<Record<string, never>>;

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

@@ -0,0 +1,31 @@
+import { type ColumnDataType, sql } from 'drizzle-orm';
+import type { LibSQLDatabase } from 'drizzle-orm/libsql';
+import { type DBColumn, type DBTable } from '../core/types.js';
+export { sql };
+export type SqliteDB = LibSQLDatabase;
+export type { Table } from './types.js';
+export { createRemoteDatabaseClient, createLocalDatabaseClient } from './db-client.js';
+export { seedLocal } from './seed-local.js';
+export declare function hasPrimaryKey(column: DBColumn): boolean;
+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 declare function asDrizzleTable(name: string, table: DBTable): import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: string;
+    schema: undefined;
+    columns: {
+        [x: string]: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: string;
+            dataType: ColumnDataType;
+            columnType: string;
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            enumValues: string[] | undefined;
+            baseColumn: never;
+        }, object>;
+    };
+    dialect: "sqlite";
+}>;

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

@@ -0,0 +1,71 @@
+import type { BooleanColumn, ColumnType, DBColumn, DBTable, DateColumn, JsonColumn, NumberColumn, TextColumn } from '../core/types.js';
+export declare const SEED_DEV_FILE_NAME: string[];
+export declare function getDropTableIfExistsQuery(tableName: string): string;
+export declare function getCreateTableQuery(tableName: string, table: DBTable): string;
+export declare function getCreateIndexQueries(tableName: string, table: Pick<DBTable, 'indexes'>): string[];
+export declare function getCreateForeignKeyQueries(tableName: string, table: DBTable): string[];
+export declare function schemaTypeToSqlType(type: ColumnType): 'text' | 'integer';
+export declare function getModifiers(columnName: string, column: DBColumn): string;
+export declare function getReferencesConfig(column: DBColumn): {
+    type: "number";
+    schema: ({
+        unique: boolean;
+        deprecated: boolean;
+        name?: string | undefined;
+        label?: string | undefined;
+        collection?: string | undefined;
+    } & {
+        optional: boolean;
+        primaryKey: false;
+        default?: number | import("./types.js").SerializedSQL | undefined;
+    } & {
+        references?: any | undefined;
+    }) | ({
+        unique: boolean;
+        deprecated: boolean;
+        name?: string | undefined;
+        label?: string | undefined;
+        collection?: string | undefined;
+    } & {
+        primaryKey: true;
+        optional?: false | undefined;
+        default?: undefined;
+    } & {
+        references?: any | undefined;
+    });
+} | {
+    type: "text";
+    schema: ({
+        unique: boolean;
+        deprecated: boolean;
+        name?: string | undefined;
+        label?: string | undefined;
+        collection?: string | undefined;
+        default?: string | import("./types.js").SerializedSQL | undefined;
+        multiline?: boolean | undefined;
+    } & {
+        optional: boolean;
+        primaryKey: false;
+    } & {
+        references?: any | undefined;
+    }) | ({
+        unique: boolean;
+        deprecated: boolean;
+        name?: string | undefined;
+        label?: string | undefined;
+        collection?: string | undefined;
+        default?: string | import("./types.js").SerializedSQL | undefined;
+        multiline?: boolean | undefined;
+    } & {
+        primaryKey: true;
+        optional?: false | undefined;
+    } & {
+        references?: any | undefined;
+    });
+} | undefined;
+type WithDefaultDefined<T extends DBColumn> = T & {
+    schema: Required<Pick<T['schema'], 'default'>>;
+};
+type DBColumnWithDefault = WithDefaultDefined<TextColumn> | WithDefaultDefined<DateColumn> | WithDefaultDefined<NumberColumn> | WithDefaultDefined<BooleanColumn> | WithDefaultDefined<JsonColumn>;
+export declare function hasDefault(column: DBColumn): column is DBColumnWithDefault;
+export {};

package/dist/_internal/runtime/seed-local.d.ts

@@ -0,0 +1,10 @@
+import type { LibSQLDatabase } from 'drizzle-orm/libsql';
+import { type DBTables } from '../core/types.js';
+export declare function seedLocal({ db, tables, userSeedGlob, integrationSeedFunctions, }: {
+    db: LibSQLDatabase;
+    tables: DBTables;
+    userSeedGlob: Record<string, {
+        default?: () => Promise<void>;
+    }>;
+    integrationSeedFunctions: Array<() => Promise<void>>;
+}): Promise<void>;

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/migration-queries.js

@@ -16,8 +16,8 @@ import {
 import { isSerializedSQL } from "../../runtime/types.js";
 import { MIGRATION_VERSION } from "../consts.js";
 import { RENAME_COLUMN_ERROR, RENAME_TABLE_ERROR } from "../errors.js";
+import { columnSchema } from "../schemas.js";
 import {
-  columnSchema
 } from "../types.js";
 import { getRemoteDatabaseUrl } from "../utils.js";
 const sqlite = new SQLiteAsyncDialect();
@@ -42,7 +42,6 @@ async function getMigrationQueries({
     );
   }
   for (const [collectionName, collection] of Object.entries(addedCollections)) {
-    queries.push(getDropTableIfExistsQuery(collectionName));
     queries.push(getCreateTableQuery(collectionName, collection));
     queries.push(...getCreateIndexQueries(collectionName, collection));
   }

package/dist/core/cli/print-help.js

@@ -27,7 +27,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"0.7.2"}`
+        `v${"0.8.1"}`
       )} ${headline}`
     );
   }

package/dist/core/integration/typegen.js

@@ -1,12 +1,11 @@
 import { existsSync } from "node:fs";
 import { mkdir, writeFile } from "node:fs/promises";
-import { DB_TYPES_FILE, RUNTIME_CONFIG_IMPORT, RUNTIME_IMPORT } from "../consts.js";
+import { DB_TYPES_FILE, RUNTIME_IMPORT } from "../consts.js";
 async function typegen({ tables, root }) {
   const content = `// This file is generated by \`studio sync\`
 declare module 'astro:db' {
 	export const db: import(${RUNTIME_IMPORT}).SqliteDB;
 	export const dbUrl: string;
-	export * from ${RUNTIME_CONFIG_IMPORT};
 
 ${Object.entries(tables).map(([name, collection]) => generateTableType(name, collection)).join("\n")}
 }

package/dist/core/load-file.d.ts

@@ -102,8 +102,8 @@ export declare function resolveDbConfig({ root, integrations }: AstroConfig): Pr
                 unique?: boolean | undefined;
             }> | undefined;
             foreignKeys?: (Omit<{
-                columns: import("./types.js").MaybeArray<string>;
-                references: () => import("./types.js").MaybeArray<Omit<{
+                columns: import("./schemas.js").MaybeArray<string>;
+                references: () => import("./schemas.js").MaybeArray<Omit<{
                     type: "number";
                     schema: ({
                         name?: string | undefined;
@@ -161,7 +161,7 @@ export declare function resolveDbConfig({ root, integrations }: AstroConfig): Pr
                     });
                 }, "references">>;
             }, "references"> & {
-                references: import("./types.js").MaybeArray<Omit<{
+                references: import("./schemas.js").MaybeArray<Omit<{
                     type: "number";
                     schema: ({
                         unique: boolean;

package/dist/core/load-file.js

@@ -7,7 +7,8 @@ import { CONFIG_FILE_NAMES, VIRTUAL_MODULE_ID } from "./consts.js";
 import { INTEGRATION_TABLE_CONFLICT_ERROR } from "./errors.js";
 import { errorMap } from "./integration/error-map.js";
 import { getConfigVirtualModContents } from "./integration/vite-plugin-db.js";
-import { dbConfigSchema } from "./types.js";
+import { dbConfigSchema } from "./schemas.js";
+import {} from "./types.js";
 import { getDbDirectoryUrl } from "./utils.js";
 const isDbIntegration = (integration) => "astro:db:setup" in integration.hooks;
 async function resolveDbConfig({ root, integrations }) {