@astrojs/db 0.0.0-10646-20240402132948

package/dist/core/schemas.js

@@ -0,0 +1,186 @@
+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";
+import { mapObject } from "./utils.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 `defineDb()` is called to resolve `references`
+  name: z.string().optional(),
+  // TODO: Update to `table`. Will need migration file version 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.discriminatedUnion("type", [
+  booleanColumnSchema,
+  numberColumnSchema,
+  textColumnSchema,
+  dateColumnSchema,
+  jsonColumnSchema
+]);
+const referenceableColumnSchema = z.union([textColumnSchema, numberColumnSchema]);
+const columnsSchema = z.record(columnSchema);
+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 resolvedIndexSchema = z.object({
+  on: z.string().or(z.array(z.string())),
+  unique: z.boolean().optional()
+});
+const legacyIndexesSchema = z.record(resolvedIndexSchema);
+const indexSchema = z.object({
+  on: z.string().or(z.array(z.string())),
+  unique: z.boolean().optional(),
+  name: z.string().optional()
+});
+const indexesSchema = z.array(indexSchema);
+const tableSchema = z.object({
+  columns: columnsSchema,
+  indexes: indexesSchema.or(legacyIndexesSchema).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)) {
+    table.getName = () => tableName;
+    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()
+}).transform(({ tables = {}, ...config }) => {
+  return {
+    ...config,
+    tables: mapObject(tables, (tableName, table) => {
+      const { indexes = {} } = table;
+      if (!Array.isArray(indexes)) {
+        return { ...table, indexes };
+      }
+      const resolvedIndexes = {};
+      for (const index of indexes) {
+        if (index.name) {
+          const { name: name2, ...rest } = index;
+          resolvedIndexes[index.name] = rest;
+          continue;
+        }
+        const indexOn = Array.isArray(index.on) ? index.on.sort().join("_") : index.on;
+        const name = tableName + "_" + indexOn + "_idx";
+        resolvedIndexes[name] = index;
+      }
+      return {
+        ...table,
+        indexes: resolvedIndexes
+      };
+    })
+  };
+});
+export {
+  booleanColumnSchema,
+  columnSchema,
+  columnsSchema,
+  dateColumnSchema,
+  dbConfigSchema,
+  indexSchema,
+  jsonColumnSchema,
+  numberColumnOptsSchema,
+  numberColumnSchema,
+  referenceableColumnSchema,
+  resolvedIndexSchema,
+  tableSchema,
+  tablesSchema,
+  textColumnOptsSchema,
+  textColumnSchema
+};

package/dist/core/tokens.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" resolution-mode="require"/>
+export declare const SESSION_LOGIN_FILE: import("url").URL;
+export declare const PROJECT_ID_FILE: import("url").URL;
+export interface ManagedAppToken {
+    token: string;
+    renew(): Promise<void>;
+    destroy(): Promise<void>;
+}
+export declare function getProjectIdFromFile(): Promise<string | undefined>;
+export declare function getSessionIdFromFile(): Promise<string | undefined>;
+export declare function getManagedAppTokenOrExit(token?: string): Promise<ManagedAppToken>;

package/dist/core/tokens.js

@@ -0,0 +1,181 @@
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { green } from "kleur/colors";
+import ora from "ora";
+import { safeFetch } from "../runtime/utils.js";
+import { MISSING_PROJECT_ID_ERROR, MISSING_SESSION_ID_ERROR } from "./errors.js";
+import { getAstroStudioEnv, getAstroStudioUrl } from "./utils.js";
+const SESSION_LOGIN_FILE = pathToFileURL(join(homedir(), ".astro", "session-token"));
+const PROJECT_ID_FILE = pathToFileURL(join(process.cwd(), ".astro", "link"));
+class ManagedLocalAppToken {
+  token;
+  constructor(token) {
+    this.token = token;
+  }
+  async renew() {
+  }
+  async destroy() {
+  }
+}
+class ManagedRemoteAppToken {
+  token;
+  session;
+  projectId;
+  ttl;
+  expires;
+  renewTimer;
+  static async create(sessionToken, projectId) {
+    const { token: shortLivedAppToken, ttl } = await this.createToken(sessionToken, projectId);
+    return new ManagedRemoteAppToken({
+      token: shortLivedAppToken,
+      session: sessionToken,
+      projectId,
+      ttl
+    });
+  }
+  static async createToken(sessionToken, projectId) {
+    const spinner = ora("Connecting to remote database...").start();
+    const response = await safeFetch(
+      new URL(`${getAstroStudioUrl()}/auth/cli/token-create`),
+      {
+        method: "POST",
+        headers: new Headers({
+          Authorization: `Bearer ${sessionToken}`
+        }),
+        body: JSON.stringify({ projectId })
+      },
+      (res) => {
+        throw new Error(`Failed to create token: ${res.status} ${res.statusText}`);
+      }
+    );
+    spinner.succeed(green("Connected to remote database."));
+    const { token, ttl } = await response.json();
+    return { token, ttl };
+  }
+  constructor(options) {
+    this.token = options.token;
+    this.session = options.session;
+    this.projectId = options.projectId;
+    this.ttl = options.ttl;
+    this.renewTimer = setTimeout(() => this.renew(), 1e3 * 60 * 5 / 2);
+    this.expires = getExpiresFromTtl(this.ttl);
+  }
+  async fetch(url, body) {
+    return safeFetch(
+      `${getAstroStudioUrl()}${url}`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.session}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body)
+      },
+      () => {
+        throw new Error(`Failed to fetch ${url}.`);
+      }
+    );
+  }
+  tokenIsValid() {
+    return /* @__PURE__ */ new Date() > this.expires;
+  }
+  createRenewTimer() {
+    return setTimeout(() => this.renew(), 1e3 * 60 * this.ttl / 2);
+  }
+  async renew() {
+    clearTimeout(this.renewTimer);
+    delete this.renewTimer;
+    if (this.tokenIsValid()) {
+      const response = await this.fetch("/auth/cli/token-renew", {
+        token: this.token,
+        projectId: this.projectId
+      });
+      if (response.status === 200) {
+        this.expires = getExpiresFromTtl(this.ttl);
+        this.renewTimer = this.createRenewTimer();
+      } else {
+        throw new Error(`Unexpected response: ${response.status} ${response.statusText}`);
+      }
+    } else {
+      try {
+        const { token, ttl } = await ManagedRemoteAppToken.createToken(
+          this.session,
+          this.projectId
+        );
+        this.token = token;
+        this.ttl = ttl;
+        this.expires = getExpiresFromTtl(ttl);
+        this.renewTimer = this.createRenewTimer();
+      } catch {
+        throw new Error(
+          `Token has expired and attempts to renew it have failed, please try again.`
+        );
+      }
+    }
+  }
+  async destroy() {
+    try {
+      const response = await this.fetch("/auth/cli/token-delete", {
+        token: this.token,
+        projectId: this.projectId
+      });
+      if (response.status !== 200) {
+        throw new Error(`Unexpected response: ${response.status} ${response.statusText}`);
+      }
+    } catch (error) {
+      console.error("Failed to delete token.", error?.message);
+    }
+  }
+}
+async function getProjectIdFromFile() {
+  try {
+    return await readFile(PROJECT_ID_FILE, "utf-8");
+  } catch (error) {
+    return void 0;
+  }
+}
+async function getSessionIdFromFile() {
+  try {
+    return await readFile(SESSION_LOGIN_FILE, "utf-8");
+  } catch (error) {
+    return void 0;
+  }
+}
+async function getManagedAppTokenOrExit(token) {
+  if (token) {
+    return new ManagedLocalAppToken(token);
+  }
+  if (process.env.ASTRO_INTERNAL_TEST_REMOTE) {
+    return new ManagedLocalAppToken(
+      "fake"
+      /* token ignored in test */
+    );
+  }
+  const { ASTRO_STUDIO_APP_TOKEN } = getAstroStudioEnv();
+  if (ASTRO_STUDIO_APP_TOKEN) {
+    return new ManagedLocalAppToken(ASTRO_STUDIO_APP_TOKEN);
+  }
+  const sessionToken = await getSessionIdFromFile();
+  if (!sessionToken) {
+    console.error(MISSING_SESSION_ID_ERROR);
+    process.exit(1);
+  }
+  const projectId = await getProjectIdFromFile();
+  if (!sessionToken || !projectId) {
+    console.error(MISSING_PROJECT_ID_ERROR);
+    process.exit(1);
+  }
+  return ManagedRemoteAppToken.create(sessionToken, projectId);
+}
+function getExpiresFromTtl(ttl) {
+  return new Date(Date.now() + ttl * 60 * 1e3);
+}
+export {
+  PROJECT_ID_FILE,
+  SESSION_LOGIN_FILE,
+  getManagedAppTokenOrExit,
+  getProjectIdFromFile,
+  getSessionIdFromFile
+};

package/dist/core/types.d.ts

@@ -0,0 +1,59 @@
+import type { AstroIntegration } from 'astro';
+import type { z } from 'zod';
+import type { MaybeArray, booleanColumnSchema, columnSchema, columnsSchema, dateColumnSchema, dbConfigSchema, indexSchema, jsonColumnSchema, numberColumnOptsSchema, numberColumnSchema, referenceableColumnSchema, resolvedIndexSchema, tableSchema, textColumnOptsSchema, textColumnSchema } from './schemas.js';
+export type ResolvedIndexes = z.output<typeof dbConfigSchema>['tables'][string]['indexes'];
+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 ResolvedDBTables = z.output<typeof dbConfigSchema>['tables'];
+export type ResolvedDBTable = z.output<typeof dbConfigSchema>['tables'][string];
+export type DBSnapshot = {
+    schema: Record<string, ResolvedDBTable>;
+    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?: Array<IndexConfig<TColumns>> | Record<string, LegacyIndexConfig<TColumns>>;
+    deprecated?: boolean;
+}
+interface IndexConfig<TColumns extends ColumnsConfig> extends z.input<typeof indexSchema> {
+    on: MaybeArray<Extract<keyof TColumns, string>>;
+}
+/** @deprecated */
+interface LegacyIndexConfig<TColumns extends ColumnsConfig> extends z.input<typeof resolvedIndexSchema> {
+    on: MaybeArray<Extract<keyof TColumns, string>>;
+}
+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/core/utils.d.ts

@@ -0,0 +1,20 @@
+import type { AstroConfig, AstroIntegration } from 'astro';
+import type { AstroDbIntegration } from './types.js';
+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;
+export declare function defineDbIntegration(integration: AstroDbIntegration): AstroIntegration;
+export type Result<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    data: unknown;
+};
+/**
+ * Map an object's values to a new set of values
+ * while preserving types.
+ */
+export declare function mapObject<T, U = T>(item: Record<string, T>, callback: (key: string, value: T) => U): Record<string, U>;

package/dist/core/utils.js

@@ -0,0 +1,32 @@
+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://studio.astro.build";
+}
+function getDbDirectoryUrl(root) {
+  return new URL("db/", root);
+}
+function defineDbIntegration(integration) {
+  return integration;
+}
+function mapObject(item, callback) {
+  return Object.fromEntries(
+    Object.entries(item).map(([key, value]) => [key, callback(key, value)])
+  );
+}
+export {
+  defineDbIntegration,
+  getAstroStudioEnv,
+  getAstroStudioUrl,
+  getDbDirectoryUrl,
+  getRemoteDatabaseUrl,
+  mapObject
+};

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/runtime/config.js

@@ -0,0 +1,111 @@
+import { LibsqlError } from "@libsql/client";
+import { sql as _sql } from "drizzle-orm";
+function createColumn(type, schema) {
+  return {
+    type,
+    /**
+     * @internal
+     */
+    schema
+  };
+}
+function isDbError(err) {
+  return err instanceof LibsqlError;
+}
+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;
+}
+const NOW = _sql`CURRENT_TIMESTAMP`;
+const TRUE = _sql`TRUE`;
+const FALSE = _sql`FALSE`;
+import {
+  sql,
+  eq,
+  gt,
+  gte,
+  lt,
+  lte,
+  ne,
+  isNull,
+  isNotNull,
+  inArray,
+  notInArray,
+  exists,
+  notExists,
+  between,
+  notBetween,
+  like,
+  notIlike,
+  not,
+  asc,
+  desc,
+  and,
+  or,
+  count,
+  countDistinct,
+  avg,
+  avgDistinct,
+  sum,
+  sumDistinct,
+  max,
+  min
+} from "drizzle-orm";
+export {
+  FALSE,
+  NOW,
+  TRUE,
+  and,
+  asc,
+  avg,
+  avgDistinct,
+  between,
+  column,
+  count,
+  countDistinct,
+  defineDb,
+  defineTable,
+  desc,
+  eq,
+  exists,
+  gt,
+  gte,
+  inArray,
+  isDbError,
+  isNotNull,
+  isNull,
+  like,
+  lt,
+  lte,
+  max,
+  min,
+  ne,
+  not,
+  notBetween,
+  notExists,
+  notIlike,
+  notInArray,
+  or,
+  sql,
+  sum,
+  sumDistinct
+};

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

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