@astrojs/db 0.0.0-edge-nested-20240223135627

package/dist/core/types.js

@@ -0,0 +1,209 @@
+import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
+import { collectionToTable } from "../runtime/index.js";
+import { z } from "zod";
+import { SQL } from "drizzle-orm";
+import { errorMap } from "./integration/error-map.js";
+import { SERIALIZED_SQL_KEY } from "../runtime/types.js";
+const sqlite = new SQLiteAsyncDialect();
+const sqlSchema = z.instanceof(SQL).transform(
+  (sqlObj) => ({
+    [SERIALIZED_SQL_KEY]: true,
+    sql: sqlite.sqlToQuery(sqlObj).sql
+  })
+);
+const baseColumnSchema = z.object({
+  label: z.string().optional(),
+  optional: z.boolean().optional().default(false),
+  unique: z.boolean().optional().default(false),
+  // Defined when `defineReadableTable()` is called
+  name: z.string().optional(),
+  collection: z.string().optional()
+});
+const booleanColumnSchema = z.object({
+  type: z.literal("boolean"),
+  schema: baseColumnSchema.extend({
+    default: z.union([z.boolean(), sqlSchema]).optional()
+  })
+});
+const numberColumnBaseSchema = baseColumnSchema.omit({ optional: true }).and(
+  z.union([
+    z.object({
+      primaryKey: z.literal(false).optional().default(false),
+      optional: baseColumnSchema.shape.optional,
+      default: z.union([z.number(), sqlSchema]).optional()
+    }),
+    z.object({
+      // `integer primary key` uses ROWID as the default value.
+      // `optional` and `default` do not have an effect,
+      // so disable these config options for primary keys.
+      primaryKey: z.literal(true),
+      optional: z.literal(false).optional(),
+      default: z.literal(void 0).optional()
+    })
+  ])
+);
+const numberColumnOptsSchema = numberColumnBaseSchema.and(
+  z.object({
+    references: z.function().returns(z.lazy(() => numberColumnSchema)).optional().transform((fn) => fn?.())
+  })
+);
+const numberColumnSchema = z.object({
+  type: z.literal("number"),
+  schema: numberColumnOptsSchema
+});
+const textColumnBaseSchema = baseColumnSchema.omit({ optional: true }).extend({
+  default: z.union([z.string(), sqlSchema]).optional(),
+  multiline: z.boolean().optional()
+}).and(
+  z.union([
+    z.object({
+      primaryKey: z.literal(false).optional().default(false),
+      optional: baseColumnSchema.shape.optional
+    }),
+    z.object({
+      // text primary key allows NULL values.
+      // NULL values bypass unique checks, which could
+      // lead to duplicate URLs per record in Astro Studio.
+      // disable `optional` for primary keys.
+      primaryKey: z.literal(true),
+      optional: z.literal(false).optional()
+    })
+  ])
+);
+const textColumnOptsSchema = textColumnBaseSchema.and(
+  z.object({
+    references: z.function().returns(z.lazy(() => textColumnSchema)).optional().transform((fn) => fn?.())
+  })
+);
+const textColumnSchema = z.object({
+  type: z.literal("text"),
+  schema: textColumnOptsSchema
+});
+const dateColumnSchema = z.object({
+  type: z.literal("date"),
+  schema: baseColumnSchema.extend({
+    default: z.union([
+      sqlSchema,
+      // transform to ISO string for serialization
+      z.date().transform((d) => d.toISOString())
+    ]).optional()
+  })
+});
+const jsonColumnSchema = z.object({
+  type: z.literal("json"),
+  schema: baseColumnSchema.extend({
+    default: z.unknown().optional()
+  })
+});
+const columnSchema = z.union([
+  booleanColumnSchema,
+  numberColumnSchema,
+  textColumnSchema,
+  dateColumnSchema,
+  jsonColumnSchema
+]);
+const referenceableColumnSchema = z.union([textColumnSchema, numberColumnSchema]);
+const columnsSchema = z.record(columnSchema);
+const indexSchema = z.object({
+  on: z.string().or(z.array(z.string())),
+  unique: z.boolean().optional()
+});
+const foreignKeysSchema = z.object({
+  columns: z.string().or(z.array(z.string())),
+  references: z.function().returns(z.lazy(() => referenceableColumnSchema.or(z.array(referenceableColumnSchema)))).transform((fn) => fn())
+});
+const baseCollectionSchema = z.object({
+  columns: columnsSchema,
+  indexes: z.record(indexSchema).optional(),
+  foreignKeys: z.array(foreignKeysSchema).optional()
+});
+const readableCollectionSchema = baseCollectionSchema.extend({
+  writable: z.literal(false)
+});
+const writableCollectionSchema = baseCollectionSchema.extend({
+  writable: z.literal(true)
+});
+const collectionSchema = z.union([readableCollectionSchema, writableCollectionSchema]);
+const tablesSchema = z.preprocess((rawCollections) => {
+  const tables = z.record(z.any()).parse(rawCollections, { errorMap });
+  for (const [collectionName, collection] of Object.entries(tables)) {
+    collection.table = collectionToTable(
+      collectionName,
+      collectionSchema.parse(collection, { errorMap })
+    );
+    const { columns } = z.object({ columns: z.record(z.any()) }).parse(collection, { errorMap });
+    for (const [columnName, column2] of Object.entries(columns)) {
+      column2.schema.name = columnName;
+      column2.schema.collection = collectionName;
+    }
+  }
+  return rawCollections;
+}, z.record(collectionSchema));
+function defineData(fn) {
+  return fn;
+}
+const dbDataFn = z.function().returns(z.union([z.void(), z.promise(z.void())]));
+const dbConfigSchema = z.object({
+  studio: z.boolean().optional(),
+  tables: tablesSchema.optional(),
+  data: z.union([dbDataFn, z.array(dbDataFn)]).optional(),
+  unsafeWritable: z.boolean().optional().default(false)
+});
+const astroConfigWithDbSchema = z.object({
+  db: dbConfigSchema.optional()
+});
+function baseDefineCollection(userConfig, writable) {
+  return {
+    ...userConfig,
+    writable,
+    // set at runtime to get the table name
+    table: null
+  };
+}
+function defineReadableTable(userConfig) {
+  return baseDefineCollection(userConfig, false);
+}
+function defineWritableTable(userConfig) {
+  return baseDefineCollection(userConfig, true);
+}
+function createColumn(type, schema) {
+  return {
+    type,
+    /**
+     * @internal
+     */
+    schema
+  };
+}
+const column = {
+  number: (opts = {}) => {
+    return createColumn("number", opts);
+  },
+  boolean: (opts = {}) => {
+    return createColumn("boolean", opts);
+  },
+  text: (opts = {}) => {
+    return createColumn("text", opts);
+  },
+  date(opts = {}) {
+    return createColumn("date", opts);
+  },
+  json(opts = {}) {
+    return createColumn("json", opts);
+  }
+};
+export {
+  astroConfigWithDbSchema,
+  collectionSchema,
+  column,
+  columnSchema,
+  dbConfigSchema,
+  defineData,
+  defineReadableTable,
+  defineWritableTable,
+  indexSchema,
+  readableCollectionSchema,
+  referenceableColumnSchema,
+  tablesSchema,
+  writableCollectionSchema
+};

package/dist/core/utils.d.ts

@@ -0,0 +1,5 @@
+import type { AstroConfig } from 'astro';
+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;

package/dist/core/utils.js

@@ -0,0 +1,18 @@
+import { loadEnv } from "vite";
+function getAstroStudioEnv(envMode = "") {
+  const env = loadEnv(envMode, process.cwd(), "ASTRO_STUDIO_");
+  return env;
+}
+function getRemoteDatabaseUrl() {
+  const env = getAstroStudioEnv();
+  return env.ASTRO_STUDIO_REMOTE_DB_URL || "https://db.services.astro.build";
+}
+function getAstroStudioUrl() {
+  const env = getAstroStudioEnv();
+  return env.ASTRO_STUDIO_URL || "https://stardate.astro.build";
+}
+export {
+  getAstroStudioEnv,
+  getAstroStudioUrl,
+  getRemoteDatabaseUrl
+};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { defineReadableTable, defineWritableTable, defineData, column } from './core/types.js';
+export type { ResolvedCollectionConfig, DBDataContext } from './core/types.js';
+export { cli } from './core/cli/index.js';
+export { integration as default } from './core/integration/index.js';
+export { sql, NOW, TRUE, FALSE } from './runtime/index.js';

package/dist/index.js

@@ -0,0 +1,16 @@
+import { defineReadableTable, defineWritableTable, defineData, column } from "./core/types.js";
+import { cli } from "./core/cli/index.js";
+import { integration } from "./core/integration/index.js";
+import { sql, NOW, TRUE, FALSE } from "./runtime/index.js";
+export {
+  FALSE,
+  NOW,
+  TRUE,
+  cli,
+  column,
+  integration as default,
+  defineData,
+  defineReadableTable,
+  defineWritableTable,
+  sql
+};

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

@@ -0,0 +1,12 @@
+/// <reference types="node" resolution-mode="require"/>
+import { type DBTables } from '../core/types.js';
+import type { LibSQLDatabase } from 'drizzle-orm/libsql';
+interface LocalDatabaseClient extends LibSQLDatabase, Disposable {
+}
+export declare function createLocalDatabaseClient({ tables, dbUrl, seeding, }: {
+    dbUrl: string;
+    tables: DBTables;
+    seeding: boolean;
+}): Promise<LocalDatabaseClient>;
+export declare function createRemoteDatabaseClient(appToken: string, remoteDbURL: string): import("drizzle-orm/sqlite-proxy").SqliteRemoteDatabase<Record<string, never>>;
+export {};

package/dist/runtime/db-client.js

@@ -0,0 +1,96 @@
+import { createClient } from "@libsql/client";
+import {} from "../core/types.js";
+import { drizzle as drizzleLibsql } from "drizzle-orm/libsql";
+import { drizzle as drizzleProxy } from "drizzle-orm/sqlite-proxy";
+import {} from "drizzle-orm/sqlite-core";
+import { z } from "zod";
+import { getTableName } from "drizzle-orm";
+const isWebContainer = !!process.versions?.webcontainer;
+async function createLocalDatabaseClient({
+  tables,
+  dbUrl,
+  seeding
+}) {
+  const url = isWebContainer ? "file:content.db" : dbUrl;
+  const client = createClient({ url });
+  const db = Object.assign(drizzleLibsql(client), {
+    [Symbol.dispose || Symbol.for("Symbol.dispose")]() {
+      client.close();
+    }
+  });
+  if (seeding)
+    return db;
+  const { insert: drizzleInsert, update: drizzleUpdate, delete: drizzleDelete } = db;
+  return Object.assign(db, {
+    insert(Table) {
+      checkIfModificationIsAllowed(tables, Table);
+      return drizzleInsert.call(this, Table);
+    },
+    update(Table) {
+      checkIfModificationIsAllowed(tables, Table);
+      return drizzleUpdate.call(this, Table);
+    },
+    delete(Table) {
+      checkIfModificationIsAllowed(tables, Table);
+      return drizzleDelete.call(this, Table);
+    }
+  });
+}
+function checkIfModificationIsAllowed(tables, Table) {
+  const tableName = getTableName(Table);
+  const collection = tables[tableName];
+  if (!collection.writable) {
+    throw new Error(`The [${tableName}] collection is read-only.`);
+  }
+}
+function createRemoteDatabaseClient(appToken, remoteDbURL) {
+  const url = new URL("/db/query", remoteDbURL);
+  const db = drizzleProxy(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 {
+  createLocalDatabaseClient,
+  createRemoteDatabaseClient
+};

package/dist/runtime/drizzle.d.ts

@@ -0,0 +1 @@
+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/runtime/drizzle.js

@@ -0,0 +1,48 @@
+import {
+  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";
+export {
+  and,
+  asc,
+  between,
+  desc,
+  eq,
+  exists,
+  gt,
+  gte,
+  inArray,
+  isNotNull,
+  isNull,
+  like,
+  lt,
+  lte,
+  ne,
+  not,
+  notBetween,
+  notExists,
+  notIlike,
+  notInArray,
+  or,
+  sql
+};

package/dist/runtime/index.d.ts

@@ -0,0 +1,30 @@
+import type { SqliteRemoteDatabase } from 'drizzle-orm/sqlite-proxy';
+import { type DBTable, type DBColumn } from '../core/types.js';
+import { type ColumnDataType, sql } from 'drizzle-orm';
+export { sql };
+export type SqliteDB = SqliteRemoteDatabase;
+export type { Table } from './types.js';
+export { createRemoteDatabaseClient, createLocalDatabaseClient } from './db-client.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 collectionToTable(name: string, collection: 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/runtime/index.js

@@ -0,0 +1,124 @@
+import {} from "../core/types.js";
+import { sql } from "drizzle-orm";
+import {
+  customType,
+  integer,
+  sqliteTable,
+  text,
+  index
+} from "drizzle-orm/sqlite-core";
+import { isSerializedSQL } from "./types.js";
+import { createRemoteDatabaseClient, createLocalDatabaseClient } from "./db-client.js";
+function hasPrimaryKey(column) {
+  return "primaryKey" in column.schema && !!column.schema.primaryKey;
+}
+const NOW = sql`CURRENT_TIMESTAMP`;
+const TRUE = sql`TRUE`;
+const FALSE = sql`FALSE`;
+const dateType = customType({
+  dataType() {
+    return "text";
+  },
+  toDriver(value) {
+    return value.toISOString();
+  },
+  fromDriver(value) {
+    return new Date(value);
+  }
+});
+const jsonType = customType({
+  dataType() {
+    return "text";
+  },
+  toDriver(value) {
+    return JSON.stringify(value);
+  },
+  fromDriver(value) {
+    return JSON.parse(value);
+  }
+});
+function collectionToTable(name, collection) {
+  const columns = {};
+  if (!Object.entries(collection.columns).some(([, column]) => hasPrimaryKey(column))) {
+    columns["_id"] = integer("_id").primaryKey();
+  }
+  for (const [columnName, column] of Object.entries(collection.columns)) {
+    columns[columnName] = columnMapper(columnName, column);
+  }
+  const table = sqliteTable(name, columns, (ormTable) => {
+    const indexes = {};
+    for (const [indexName, indexProps] of Object.entries(collection.indexes ?? {})) {
+      const onColNames = Array.isArray(indexProps.on) ? indexProps.on : [indexProps.on];
+      const onCols = onColNames.map((colName) => ormTable[colName]);
+      if (!atLeastOne(onCols))
+        continue;
+      indexes[indexName] = index(indexName).on(...onCols);
+    }
+    return indexes;
+  });
+  return table;
+}
+function atLeastOne(arr) {
+  return arr.length > 0;
+}
+function columnMapper(columnName, column) {
+  let c;
+  switch (column.type) {
+    case "text": {
+      c = text(columnName);
+      if (column.schema.default !== void 0)
+        c = c.default(handleSerializedSQL(column.schema.default));
+      if (column.schema.primaryKey === true)
+        c = c.primaryKey();
+      break;
+    }
+    case "number": {
+      c = integer(columnName);
+      if (column.schema.default !== void 0)
+        c = c.default(handleSerializedSQL(column.schema.default));
+      if (column.schema.primaryKey === true)
+        c = c.primaryKey();
+      break;
+    }
+    case "boolean": {
+      c = integer(columnName, { mode: "boolean" });
+      if (column.schema.default !== void 0)
+        c = c.default(handleSerializedSQL(column.schema.default));
+      break;
+    }
+    case "json":
+      c = jsonType(columnName);
+      if (column.schema.default !== void 0)
+        c = c.default(column.schema.default);
+      break;
+    case "date": {
+      c = dateType(columnName);
+      if (column.schema.default !== void 0) {
+        const def = handleSerializedSQL(column.schema.default);
+        c = c.default(typeof def === "string" ? new Date(def) : def);
+      }
+      break;
+    }
+  }
+  if (!column.schema.optional)
+    c = c.notNull();
+  if (column.schema.unique)
+    c = c.unique();
+  return c;
+}
+function handleSerializedSQL(def) {
+  if (isSerializedSQL(def)) {
+    return sql.raw(def.sql);
+  }
+  return def;
+}
+export {
+  FALSE,
+  NOW,
+  TRUE,
+  collectionToTable,
+  createLocalDatabaseClient,
+  createRemoteDatabaseClient,
+  hasPrimaryKey,
+  sql
+};

package/dist/runtime/types.d.ts

@@ -0,0 +1,69 @@
+import type { ColumnDataType, ColumnBaseConfig } from 'drizzle-orm';
+import type { SQLiteColumn, SQLiteTableWithColumns } from 'drizzle-orm/sqlite-core';
+import type { DBColumn, ColumnsConfig } 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 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/index.d.ts

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