@astrojs/db 0.0.0-db-export-bug-20240307130354

package/dist/core/types.js

@@ -0,0 +1,143 @@
+import { SQL } from "drizzle-orm";
+import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
+import { z } from "zod";
+import { SERIALIZED_SQL_KEY } from "../runtime/types.js";
+import { errorMap } from "./integration/error-map.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),
+  deprecated: z.boolean().optional().default(false),
+  // Defined when `defineReadableTable()` is called
+  name: z.string().optional(),
+  // TODO: rename to `tableName`. Breaking schema change
+  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 tableSchema = z.object({
+  columns: columnsSchema,
+  indexes: z.record(indexSchema).optional(),
+  foreignKeys: z.array(foreignKeysSchema).optional(),
+  deprecated: z.boolean().optional().default(false)
+});
+const tablesSchema = z.preprocess((rawTables) => {
+  const tables = z.record(z.any()).parse(rawTables, { errorMap });
+  for (const [tableName, table] of Object.entries(tables)) {
+    const { columns } = z.object({ columns: z.record(z.any()) }).parse(table, { errorMap });
+    for (const [columnName, column] of Object.entries(columns)) {
+      column.schema.name = columnName;
+      column.schema.collection = tableName;
+    }
+  }
+  return rawTables;
+}, z.record(tableSchema));
+const dbConfigSchema = z.object({
+  tables: tablesSchema.optional()
+});
+export {
+  columnSchema,
+  dbConfigSchema,
+  indexSchema,
+  referenceableColumnSchema,
+  tableSchema,
+  tablesSchema
+};

package/dist/core/utils.d.ts

@@ -0,0 +1,6 @@
+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;
+export declare function getDbDirectoryUrl(root: URL | string): URL;

package/dist/core/utils.js

@@ -0,0 +1,22 @@
+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";
+}
+function getDbDirectoryUrl(root) {
+  return new URL("db/", root);
+}
+export {
+  getAstroStudioEnv,
+  getAstroStudioUrl,
+  getDbDirectoryUrl,
+  getRemoteDatabaseUrl
+};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export type { ResolvedCollectionConfig, TableConfig } from './core/types.js';
+export { cli } from './core/cli/index.js';
+export { integration as default } from './core/integration/index.js';

package/dist/index.js

@@ -0,0 +1,6 @@
+import { cli } from "./core/cli/index.js";
+import { integration } from "./core/integration/index.js";
+export {
+  cli,
+  integration as default
+};

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

@@ -0,0 +1,87 @@
+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);
+  }
+};
+function defineTable(userConfig) {
+  return userConfig;
+}
+function defineDB(userConfig) {
+  return userConfig;
+}
+import { NOW, TRUE, FALSE } from "./index.js";
+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 {
+  FALSE,
+  NOW,
+  TRUE,
+  and,
+  asc,
+  between,
+  column,
+  defineDB,
+  defineTable,
+  desc,
+  eq,
+  exists,
+  gt,
+  gte,
+  inArray,
+  isNotNull,
+  isNull,
+  like,
+  lt,
+  lte,
+  ne,
+  not,
+  notBetween,
+  notExists,
+  notIlike,
+  notInArray,
+  or,
+  sql
+};

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

@@ -0,0 +1,64 @@
+import { createClient } from "@libsql/client";
+import { drizzle as drizzleLibsql } from "drizzle-orm/libsql";
+import { drizzle as drizzleProxy } from "drizzle-orm/sqlite-proxy";
+import { z } from "zod";
+const isWebContainer = !!process.versions?.webcontainer;
+function createLocalDatabaseClient({ dbUrl }) {
+  const url = isWebContainer ? "file:content.db" : dbUrl;
+  const client = createClient({ url: process.env.TEST_IN_MEMORY_DB ? ":memory:" : url });
+  const db = drizzleLibsql(client);
+  return db;
+}
+function createRemoteDatabaseClient(appToken, remoteDbURL) {
+  const url = new URL("/db/query", remoteDbURL);
+  const db = drizzleProxy(async (sql, parameters, method) => {
+    const requestBody = { sql, args: parameters };
+    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 };
+  });
+  db.batch = (_drizzleQueries) => {
+    throw new Error("db.batch() is not currently supported.");
+  };
+  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,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 './queries.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/runtime/index.js

@@ -0,0 +1,126 @@
+import { sql } from "drizzle-orm";
+import {
+  customType,
+  index,
+  integer,
+  sqliteTable,
+  text
+} from "drizzle-orm/sqlite-core";
+import {} from "../core/types.js";
+import { isSerializedSQL } from "./types.js";
+import { createRemoteDatabaseClient, createLocalDatabaseClient } from "./db-client.js";
+import { seedLocal } from "./queries.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 asDrizzleTable(name, table) {
+  const columns = {};
+  if (!Object.entries(table.columns).some(([, column]) => hasPrimaryKey(column))) {
+    columns["_id"] = integer("_id").primaryKey();
+  }
+  for (const [columnName, column] of Object.entries(table.columns)) {
+    columns[columnName] = columnMapper(columnName, column);
+  }
+  const drizzleTable = sqliteTable(name, columns, (ormTable) => {
+    const indexes = {};
+    for (const [indexName, indexProps] of Object.entries(table.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 drizzleTable;
+}
+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,
+  asDrizzleTable,
+  createLocalDatabaseClient,
+  createRemoteDatabaseClient,
+  hasPrimaryKey,
+  seedLocal,
+  sql
+};