@astrojs/db 0.0.0-10646-20240402132948

package/dist/runtime/seed-local.js

@@ -0,0 +1,55 @@
+import { LibsqlError } from "@libsql/client";
+import { sql } from "drizzle-orm";
+import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
+import {} from "../core/types.js";
+import { AstroDbError } from "./utils.js";
+import { SEED_DEFAULT_EXPORT_ERROR } from "./errors.js";
+import { getCreateIndexQueries, getCreateTableQuery } from "./queries.js";
+const sqlite = new SQLiteAsyncDialect();
+async function seedLocal({
+  db,
+  tables,
+  // Glob all potential seed files to catch renames and deletions.
+  userSeedGlob,
+  integrationSeedFunctions
+}) {
+  await recreateTables({ db, tables });
+  const seedFunctions = [];
+  const seedFilePath = Object.keys(userSeedGlob)[0];
+  if (seedFilePath) {
+    const mod = userSeedGlob[seedFilePath];
+    if (!mod.default)
+      throw new AstroDbError(SEED_DEFAULT_EXPORT_ERROR(seedFilePath));
+    seedFunctions.push(mod.default);
+  }
+  for (const seedFn of integrationSeedFunctions) {
+    seedFunctions.push(seedFn);
+  }
+  for (const seed of seedFunctions) {
+    try {
+      await seed();
+    } catch (e) {
+      if (e instanceof LibsqlError) {
+        throw new AstroDbError(`Failed to seed database:
+${e.message}`);
+      }
+      throw e;
+    }
+  }
+}
+async function recreateTables({ db, tables }) {
+  const setupQueries = [];
+  for (const [name, table] of Object.entries(tables)) {
+    const dropQuery = sql.raw(`DROP TABLE IF EXISTS ${sqlite.escapeName(name)}`);
+    const createQuery = sql.raw(getCreateTableQuery(name, table));
+    const indexQueries = getCreateIndexQueries(name, table);
+    setupQueries.push(dropQuery, createQuery, ...indexQueries.map((s) => sql.raw(s)));
+  }
+  await db.batch([
+    db.run(sql`pragma defer_foreign_keys=true;`),
+    ...setupQueries.map((q) => db.run(q))
+  ]);
+}
+export {
+  seedLocal
+};

package/dist/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/runtime/types.js

@@ -0,0 +1,8 @@
+const SERIALIZED_SQL_KEY = "__serializedSQL";
+function isSerializedSQL(value) {
+  return typeof value === "object" && value !== null && SERIALIZED_SQL_KEY in value;
+}
+export {
+  SERIALIZED_SQL_KEY,
+  isSerializedSQL
+};

package/dist/runtime/utils.d.ts

@@ -0,0 +1,8 @@
+import { AstroError } from 'astro/errors';
+/**
+ * Small wrapper around fetch that throws an error if the response is not OK. Allows for custom error handling as well through the onNotOK callback.
+ */
+export declare function safeFetch(url: Parameters<typeof fetch>[0], options?: Parameters<typeof fetch>[1], onNotOK?: (response: Response) => void | Promise<void>): Promise<Response>;
+export declare class AstroDbError extends AstroError {
+    name: string;
+}

package/dist/runtime/utils.js

@@ -0,0 +1,17 @@
+import { AstroError } from "astro/errors";
+async function safeFetch(url, options = {}, onNotOK = () => {
+  throw new Error(`Request to ${url} returned a non-OK status code.`);
+}) {
+  const response = await fetch(url, options);
+  if (!response.ok) {
+    await onNotOK(response);
+  }
+  return response;
+}
+class AstroDbError extends AstroError {
+  name = "Astro DB Error";
+}
+export {
+  AstroDbError,
+  safeFetch
+};

package/dist/utils.d.ts

@@ -0,0 +1,2 @@
+export { defineDbIntegration } from './core/utils.js';
+export { asDrizzleTable } from './runtime/index.js';

package/dist/utils.js

@@ -0,0 +1,6 @@
+import { defineDbIntegration } from "./core/utils.js";
+import { asDrizzleTable } from "./runtime/index.js";
+export {
+  asDrizzleTable,
+  defineDbIntegration
+};

package/index.d.ts

@@ -0,0 +1,3 @@
+import './virtual.js';
+
+export { default, cli } from './dist/index.js';

package/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "@astrojs/db",
+  "version": "0.0.0-10646-20240402132948",
+  "description": "",
+  "license": "MIT",
+  "type": "module",
+  "author": "withastro",
+  "types": "./index.d.ts",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./utils": {
+      "types": "./dist/utils.d.ts",
+      "import": "./dist/utils.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime/index.d.ts",
+      "import": "./dist/runtime/index.js"
+    },
+    "./dist/runtime/config.js": {
+      "import": "./dist/runtime/config.js"
+    },
+    "./types": {
+      "types": "./dist/core/types.d.ts",
+      "import": "./dist/core/types.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./index.d.ts"
+      ],
+      "types": [
+        "./dist/types.d.ts"
+      ],
+      "utils": [
+        "./dist/utils.d.ts"
+      ],
+      "runtime": [
+        "./dist/runtime/index.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "index.d.ts",
+    "virtual.d.ts",
+    "dist"
+  ],
+  "keywords": [
+    "withastro",
+    "astro-integration"
+  ],
+  "dependencies": {
+    "@libsql/client": "^0.5.5",
+    "async-listen": "^3.0.1",
+    "deep-diff": "^1.0.2",
+    "drizzle-orm": "^0.30.4",
+    "github-slugger": "^2.0.0",
+    "kleur": "^4.1.5",
+    "nanoid": "^5.0.1",
+    "open": "^10.0.3",
+    "ora": "^7.0.1",
+    "prompts": "^2.4.2",
+    "strip-ansi": "^7.1.0",
+    "yargs-parser": "^21.1.1",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/chai": "^4.3.6",
+    "@types/deep-diff": "^1.0.5",
+    "@types/diff": "^5.0.8",
+    "@types/mocha": "^10.0.2",
+    "@types/prompts": "^2.4.8",
+    "@types/yargs-parser": "^21.0.3",
+    "chai": "^4.3.10",
+    "cheerio": "1.0.0-rc.12",
+    "mocha": "^10.2.0",
+    "typescript": "^5.2.2",
+    "vite": "^5.1.4",
+    "astro-scripts": "0.0.14",
+    "astro": "4.5.13"
+  },
+  "scripts": {
+    "types:config": "tsc -p ./tsconfig.config-types.json",
+    "build": "astro-scripts build \"src/**/*.ts\" && tsc && pnpm types:config",
+    "build:ci": "astro-scripts build \"src/**/*.ts\"",
+    "dev": "astro-scripts dev \"src/**/*.ts\"",
+    "test": "mocha --exit --timeout 20000 \"test/*.js\" \"test/unit/**/*.js\"",
+    "test:match": "mocha --timeout 20000 \"test/*.js\" \"test/unit/*.js\" -g"
+  }
+}

package/virtual.d.ts

@@ -0,0 +1,45 @@
+declare module 'astro:db' {
+	type RuntimeConfig = typeof import('./dist/_internal/runtime/config.js');
+
+	export const db: import('./dist/_internal/runtime/config.js').Database;
+	export const dbUrl: string;
+
+	export const sql: RuntimeConfig['sql'];
+	export const NOW: RuntimeConfig['NOW'];
+	export const TRUE: RuntimeConfig['TRUE'];
+	export const FALSE: RuntimeConfig['FALSE'];
+	export const column: RuntimeConfig['column'];
+	export const defineDb: RuntimeConfig['defineDb'];
+	export const defineTable: RuntimeConfig['defineTable'];
+	export const isDbError: RuntimeConfig['isDbError'];
+
+	export const eq: RuntimeConfig['eq'];
+	export const gt: RuntimeConfig['gt'];
+	export const gte: RuntimeConfig['gte'];
+	export const lt: RuntimeConfig['lt'];
+	export const lte: RuntimeConfig['lte'];
+	export const ne: RuntimeConfig['ne'];
+	export const isNull: RuntimeConfig['isNull'];
+	export const isNotNull: RuntimeConfig['isNotNull'];
+	export const inArray: RuntimeConfig['inArray'];
+	export const notInArray: RuntimeConfig['notInArray'];
+	export const exists: RuntimeConfig['exists'];
+	export const notExists: RuntimeConfig['notExists'];
+	export const between: RuntimeConfig['between'];
+	export const notBetween: RuntimeConfig['notBetween'];
+	export const like: RuntimeConfig['like'];
+	export const notIlike: RuntimeConfig['notIlike'];
+	export const not: RuntimeConfig['not'];
+	export const asc: RuntimeConfig['asc'];
+	export const desc: RuntimeConfig['desc'];
+	export const and: RuntimeConfig['and'];
+	export const or: RuntimeConfig['or'];
+	export const count: RuntimeConfig['count'];
+	export const countDistinct: RuntimeConfig['countDistinct'];
+	export const avg: RuntimeConfig['avg'];
+	export const avgDistinct: RuntimeConfig['avgDistinct'];
+	export const sum: RuntimeConfig['sum'];
+	export const sumDistinct: RuntimeConfig['sumDistinct'];
+	export const max: RuntimeConfig['max'];
+	export const min: RuntimeConfig['min'];
+}