@astrojs/db 0.1.0

package/dist/types.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+const baseFieldSchema = z.object({
+  label: z.string().optional(),
+  optional: z.boolean().optional(),
+  unique: z.boolean().optional()
+});
+const booleanFieldSchema = baseFieldSchema.extend({
+  type: z.literal("boolean"),
+  default: z.boolean().optional()
+});
+const numberFieldSchema = baseFieldSchema.extend({
+  type: z.literal("number"),
+  default: z.number().optional()
+});
+const textFieldSchema = baseFieldSchema.extend({
+  type: z.literal("text"),
+  multiline: z.boolean().optional(),
+  default: z.string().optional()
+});
+const dateFieldSchema = baseFieldSchema.extend({
+  type: z.literal("date"),
+  default: z.union([
+    z.literal("now"),
+    // allow date-like defaults in user config,
+    // transform to ISO string for D1 storage
+    z.coerce.date().transform((d) => d.toISOString())
+  ]).optional()
+});
+const jsonFieldSchema = baseFieldSchema.extend({
+  type: z.literal("json"),
+  default: z.unknown().optional()
+});
+const fieldSchema = z.union([
+  booleanFieldSchema,
+  numberFieldSchema,
+  textFieldSchema,
+  dateFieldSchema,
+  jsonFieldSchema
+]);
+const fieldsSchema = z.record(fieldSchema);
+const readableCollectionSchema = z.object({
+  fields: fieldsSchema,
+  data: z.function().returns(z.array(z.record(z.unknown()))).optional(),
+  writable: z.literal(false)
+});
+const writableCollectionSchema = z.object({
+  fields: fieldsSchema,
+  seed: z.function().returns(z.array(z.record(z.unknown()))).optional(),
+  writable: z.literal(true)
+});
+const collectionSchema = z.union([readableCollectionSchema, writableCollectionSchema]);
+const collectionsSchema = z.record(collectionSchema);
+export {
+  collectionSchema,
+  collectionsSchema,
+  readableCollectionSchema,
+  writableCollectionSchema
+};

package/dist/utils.d.ts

@@ -0,0 +1,59 @@
+import type { AstroConfig } from 'astro';
+export type VitePlugin = Required<AstroConfig['vite']>['plugins'][number];
+export declare const STUDIO_ADMIN_TABLE = "ReservedAstroStudioAdmin";
+export declare const STUDIO_ADMIN_TABLE_ROW_ID = "admin";
+export declare const adminTable: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "ReservedAstroStudioAdmin";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "ReservedAstroStudioAdmin";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, object>;
+        collections: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "collections";
+            tableName: "ReservedAstroStudioAdmin";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, object>;
+    };
+    dialect: "sqlite";
+}>;
+export declare const STUDIO_MIGRATIONS_TABLE = "ReservedAstroStudioMigrations";
+export declare const migrationsTable: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "ReservedAstroStudioMigrations";
+    schema: undefined;
+    columns: {
+        name: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "name";
+            tableName: "ReservedAstroStudioMigrations";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, object>;
+    };
+    dialect: "sqlite";
+}>;
+export declare function getAstroStudioEnv(envMode?: string): Record<`ASTRO_STUDIO_${string}`, string>;
+export declare function getStudioUrl(): string;
+export declare function getRemoteDatabaseUrl(): string;
+export declare function createRemoteDatabaseClient(appToken: string): import("drizzle-orm/sqlite-proxy").SqliteRemoteDatabase<Record<string, never>>;

package/dist/utils.js

@@ -0,0 +1,84 @@
+import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
+import { drizzle } from "drizzle-orm/sqlite-proxy";
+import { loadEnv } from "vite";
+import { z } from "zod";
+const STUDIO_ADMIN_TABLE = "ReservedAstroStudioAdmin";
+const STUDIO_ADMIN_TABLE_ROW_ID = "admin";
+const adminTable = sqliteTable(STUDIO_ADMIN_TABLE, {
+  id: text("id").primaryKey(),
+  collections: text("collections").notNull()
+});
+const STUDIO_MIGRATIONS_TABLE = "ReservedAstroStudioMigrations";
+const migrationsTable = sqliteTable(STUDIO_MIGRATIONS_TABLE, {
+  name: text("name").primaryKey()
+});
+function getAstroStudioEnv(envMode = "") {
+  const env = loadEnv(envMode, process.cwd(), "ASTRO_STUDIO_");
+  return env;
+}
+function getStudioUrl() {
+  const env = getAstroStudioEnv();
+  return env.ASTRO_STUDIO_BASE_URL;
+}
+function getRemoteDatabaseUrl() {
+  const env = getAstroStudioEnv();
+  return env.ASTRO_STUDIO_REMOTE_DB_URL;
+}
+function createRemoteDatabaseClient(appToken) {
+  const url = new URL("./db/query/", getRemoteDatabaseUrl());
+  const db = drizzle(async (sql, parameters, method) => {
+    const requestBody = { sql, args: parameters };
+    console.info(JSON.stringify(requestBody));
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${appToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(requestBody)
+    });
+    if (!res.ok) {
+      throw new Error(
+        `Failed to execute query.
+Query: ${sql}
+Full error: ${res.status} ${await res.text()}}`
+      );
+    }
+    const queryResultSchema = z.object({
+      rows: z.array(z.unknown())
+    });
+    let rows;
+    try {
+      const json = await res.json();
+      rows = queryResultSchema.parse(json).rows;
+    } catch (e) {
+      throw new Error(
+        `Failed to execute query.
+Query: ${sql}
+Full error: Unexpected JSON response. ${e instanceof Error ? e.message : String(e)}`
+      );
+    }
+    const rowValues = [];
+    for (const row of rows) {
+      if (row != null && typeof row === "object") {
+        rowValues.push(Object.values(row));
+      }
+    }
+    if (method === "get") {
+      return { rows: rowValues[0] };
+    }
+    return { rows: rowValues };
+  });
+  return db;
+}
+export {
+  STUDIO_ADMIN_TABLE,
+  STUDIO_ADMIN_TABLE_ROW_ID,
+  STUDIO_MIGRATIONS_TABLE,
+  adminTable,
+  createRemoteDatabaseClient,
+  getAstroStudioEnv,
+  getRemoteDatabaseUrl,
+  getStudioUrl,
+  migrationsTable
+};

package/dist/vite-plugin-db.d.ts

@@ -0,0 +1,19 @@
+import type { DBCollections } from './types.js';
+import type { VitePlugin } from './utils.js';
+export declare function vitePluginDb(params: {
+    connectToStudio: false;
+    collections: DBCollections;
+    dbUrl: string;
+} | {
+    connectToStudio: true;
+    collections: DBCollections;
+    appToken: string;
+}): VitePlugin;
+export declare function getVirtualModContents({ collections, dbUrl, }: {
+    collections: DBCollections;
+    dbUrl: string;
+}): string;
+export declare function getStudioVirtualModContents({ collections, appToken, }: {
+    collections: DBCollections;
+    appToken: string;
+}): string;

package/dist/vite-plugin-db.js

@@ -0,0 +1,66 @@
+import { DRIZZLE_MOD_IMPORT, INTERNAL_MOD_IMPORT, VIRTUAL_MODULE_ID } from "./consts.js";
+const resolvedVirtualModuleId = "\0" + VIRTUAL_MODULE_ID;
+function vitePluginDb(params) {
+  return {
+    name: "astro:db",
+    enforce: "pre",
+    resolveId(id) {
+      if (id === VIRTUAL_MODULE_ID) {
+        return resolvedVirtualModuleId;
+      }
+    },
+    load(id) {
+      if (id !== resolvedVirtualModuleId)
+        return;
+      if (params.connectToStudio) {
+        return getStudioVirtualModContents(params);
+      }
+      return getVirtualModContents(params);
+    }
+  };
+}
+function getVirtualModContents({
+  collections,
+  dbUrl
+}) {
+  return `
+import { collectionToTable, createLocalDatabaseClient } from ${INTERNAL_MOD_IMPORT};
+
+export const db = await createLocalDatabaseClient(${JSON.stringify({
+    collections,
+    dbUrl,
+    seeding: false
+  })});
+
+export * from ${DRIZZLE_MOD_IMPORT};
+
+${getStringifiedCollectionExports(collections)}
+`;
+}
+function getStudioVirtualModContents({
+  collections,
+  appToken
+}) {
+  return `
+import {collectionToTable, createRemoteDatabaseClient} from ${INTERNAL_MOD_IMPORT};
+
+export const db = await createRemoteDatabaseClient(${JSON.stringify({
+    appToken
+  })});
+export * from ${DRIZZLE_MOD_IMPORT};
+
+${getStringifiedCollectionExports(collections)}
+	`;
+}
+function getStringifiedCollectionExports(collections) {
+  return Object.entries(collections).map(
+    ([name, collection]) => `export const ${name} = collectionToTable(${JSON.stringify(name)}, ${JSON.stringify(
+      collection
+    )}, false)`
+  ).join("\n");
+}
+export {
+  getStudioVirtualModContents,
+  getVirtualModContents,
+  vitePluginDb
+};

package/dist/vite-plugin-inject-env-ts.d.ts

@@ -0,0 +1,9 @@
+import type { VitePlugin } from './utils.js';
+export declare function vitePluginInjectEnvTs({ srcDir, root }: {
+    srcDir: URL;
+    root: URL;
+}): VitePlugin;
+export declare function setUpEnvTs({ srcDir, root }: {
+    srcDir: URL;
+    root: URL;
+}): Promise<void>;

package/dist/vite-plugin-inject-env-ts.js

@@ -0,0 +1,49 @@
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { bold, cyan } from "kleur/colors";
+import { normalizePath } from "vite";
+import { DB_TYPES_FILE } from "./consts.js";
+function vitePluginInjectEnvTs({ srcDir, root }) {
+  return {
+    name: "db-inject-env-ts",
+    enforce: "post",
+    async config() {
+      await setUpEnvTs({ srcDir, root });
+    }
+  };
+}
+async function setUpEnvTs({ srcDir, root }) {
+  const envTsPath = getEnvTsPath({ srcDir });
+  const envTsPathRelativetoRoot = normalizePath(
+    path.relative(fileURLToPath(root), fileURLToPath(envTsPath))
+  );
+  if (existsSync(envTsPath)) {
+    let typesEnvContents = await readFile(envTsPath, "utf-8");
+    const dotAstroDir = new URL(".astro/", root);
+    if (!existsSync(dotAstroDir))
+      return;
+    const dbTypeReference = getDBTypeReference({ srcDir, dotAstroDir });
+    if (!typesEnvContents.includes(dbTypeReference)) {
+      typesEnvContents = `${dbTypeReference}
+${typesEnvContents}`;
+      await writeFile(envTsPath, typesEnvContents, "utf-8");
+      console.info(`${cyan(bold("[astro:db]"))} Added ${bold(envTsPathRelativetoRoot)} types`);
+    }
+  }
+}
+function getDBTypeReference({ srcDir, dotAstroDir }) {
+  const dbTypesFile = new URL(DB_TYPES_FILE, dotAstroDir);
+  const contentTypesRelativeToSrcDir = normalizePath(
+    path.relative(fileURLToPath(srcDir), fileURLToPath(dbTypesFile))
+  );
+  return `/// <reference path=${JSON.stringify(contentTypesRelativeToSrcDir)} />`;
+}
+function getEnvTsPath({ srcDir }) {
+  return new URL("env.d.ts", srcDir);
+}
+export {
+  setUpEnvTs,
+  vitePluginInjectEnvTs
+};

package/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="./config-augment.d.ts" />
+export * from './dist/index.js';
+export { default } from './dist/index.js';

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@astrojs/db",
+  "version": "0.1.0",
+  "description": "",
+  "license": "MIT",
+  "type": "module",
+  "types": "./index.d.ts",
+  "author": "withastro",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./components": "./components/index.ts",
+    "./internal": {
+      "types": "./dist/internal.d.ts",
+      "import": "./dist/internal.js"
+    },
+    "./internal-drizzle": {
+      "types": "./dist/internal-drizzle.d.ts",
+      "import": "./dist/internal-drizzle.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./index.d.ts"
+      ],
+      "internal": [
+        "./dist/internal.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "index.d.ts",
+    "config-augment.d.ts",
+    "dist",
+    "components"
+  ],
+  "dependencies": {
+    "@libsql/client": "0.4.0-pre.5",
+    "deep-diff": "^1.0.2",
+    "drizzle-orm": "^0.28.6",
+    "kleur": "^4.1.5",
+    "nanoid": "^5.0.1",
+    "prompts": "^2.4.2",
+    "yargs-parser": "^21.1.1",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/deep-diff": "^1.0.5",
+    "@types/diff": "^5.0.8",
+    "@types/yargs-parser": "^21.0.3",
+    "@types/chai": "^4.3.6",
+    "@types/mocha": "^10.0.2",
+    "@types/prompts": "^2.4.8",
+    "chai": "^4.3.10",
+    "cheerio": "1.0.0-rc.12",
+    "mocha": "^10.2.0",
+    "typescript": "^5.2.2",
+    "vite": "^4.4.11",
+    "astro": "4.2.1",
+    "astro-scripts": "0.0.14"
+  },
+  "scripts": {
+    "build": "astro-scripts build \"src/**/*.ts\" && tsc",
+    "build:ci": "astro-scripts build \"src/**/*.ts\"",
+    "dev": "astro-scripts dev \"src/**/*.ts\"",
+    "test": "mocha --exit --timeout 20000",
+    "test:match": "mocha --timeout 20000 -g"
+  }
+}