alinea/dist/backend/api/DatabaseApi.js

Headless git-based CMS

import {
  blob,
  text
} from "../../chunks/chunk-R2IV7GJV.js";
import {
  eq
} from "../../chunks/chunk-TO6JVYUN.js";
import {
  table
} from "../../chunks/chunk-H54PGW2N.js";
import {
  getData,
  getField,
  internalConstraint,
  internalData,
  sql
} from "../../chunks/chunk-PNILF4WM.js";
import {
  PLazy
} from "../../chunks/chunk-IKINPSS5.js";
import "../../chunks/chunk-NZLE2WMY.js";

// src/backend/api/DatabaseApi.ts
import { parseDraftKey } from "alinea/core/Draft";
import { createId } from "alinea/core/Id";
import { basename, extname } from "alinea/core/util/Paths";
import { slugify } from "alinea/core/util/Slugs";

// node_modules/rado/dist/core/Constraint.js
var UniqueConstraint = class _UniqueConstraint {
  [internalData];
  constructor(data) {
    this[internalData] = data;
  }
  on(...columns) {
    const fields = columns.map(getField);
    return new _UniqueConstraint({ ...getData(this), fields });
  }
  nullsNotDistinct() {
    return new _UniqueConstraint({ ...getData(this), nullsNotDistinct: true });
  }
  get [internalConstraint]() {
    const { fields, nullsNotDistinct } = getData(this);
    return sql.join([
      sql`unique`,
      nullsNotDistinct ? sql`nulls not distinct` : void 0,
      sql`(${sql.join(
        fields.map((field) => sql.identifier(field.fieldName)),
        sql`, `
      )})`
    ]);
  }
};
var PrimaryKeyConstraint = class {
  constructor(data) {
    this.data = data;
    this[internalData] = data;
  }
  [internalData];
  get [internalConstraint]() {
    const { fields } = getData(this);
    return sql`primary key (${sql.join(
      fields.map((field) => sql.identifier(field.fieldName)),
      sql`, `
    )})`;
  }
};
function primaryKey(...fields) {
  return new PrimaryKeyConstraint({ fields: fields.map(getField) });
}
var ForeignKeyConstraint = class _ForeignKeyConstraint {
  [internalData];
  constructor(data) {
    this[internalData] = data;
  }
  references(...fields) {
    return new _ForeignKeyConstraint({
      ...getData(this),
      references: fields.map(getField)
    });
  }
  get [internalConstraint]() {
    const { fields, references } = getData(this);
    return sql`foreign key (${sql.join(
      fields.map((field) => sql.identifier(field.fieldName)),
      sql`, `
    )}) references ${sql.identifier(references[0].targetName)} (${sql.join(
      references.map((field) => sql.identifier(field.fieldName)),
      sql`, `
    )})`;
  }
};

// src/backend/api/DatabaseApi.ts
import { HandleAction } from "../HandleAction.js";
import { is } from "../util/ORM.js";
var DraftTable = table(
  "alinea_draft",
  {
    entryId: text().notNull(),
    locale: text(),
    fileHash: text().notNull(),
    draft: blob().notNull()
  },
  (Draft) => {
    return {
      primary: primaryKey(Draft.entryId, Draft.locale)
    };
  }
);
var UploadTable = table("alinea_upload", {
  entryId: text().primaryKey(),
  content: blob().notNull()
});
var DatabaseApi = class {
  #context;
  #db;
  constructor(context, { db }) {
    this.#context = context;
    this.#db = PLazy.from(async () => {
      await db.create(DraftTable, UploadTable).catch(() => {
      });
      return db;
    });
  }
  async getDraft(draftKey) {
    const db = await this.#db;
    const { entryId, locale } = parseDraftKey(draftKey);
    const found = await db.select().from(DraftTable).where(eq(DraftTable.entryId, entryId), is(DraftTable.locale, locale)).get();
    return found ?? void 0;
  }
  async storeDraft(draft) {
    const db = await this.#db;
    const query = db.dialect.runtime === "mysql" ? db.insert(DraftTable).values(draft).onDuplicateKeyUpdate({
      set: draft
    }) : db.insert(DraftTable).values(draft).onConflictDoUpdate({
      target: DraftTable.entryId,
      set: draft
    });
    await query;
  }
  async prepareUpload(file) {
    const ctx = this.#context;
    const entryId = createId();
    const extension = extname(file);
    const base = basename(file, extension);
    const filename = [slugify(base), entryId, slugify(extension)].join(".");
    const url = new URL(
      `?${new URLSearchParams({
        action: HandleAction.Upload,
        entryId
      })}`,
      ctx.handlerUrl
    );
    return {
      entryId,
      location: filename,
      previewUrl: url.href,
      url: url.href
    };
  }
  async handleUpload(entryId, file) {
    const db = await this.#db;
    const content = new Uint8Array(await file.arrayBuffer());
    await db.insert(UploadTable).values({
      entryId,
      content
    });
  }
  async previewUpload(entryId) {
    const db = await this.#db;
    const upload = await db.select().from(UploadTable).where(eq(UploadTable.entryId, entryId)).get();
    if (!upload) return new Response("Not found", { status: 404 });
    return new Response(upload.content, {
      headers: {
        "content-type": "application/octet-stream",
        "content-disposition": `inline; filename="${entryId}"`
      }
    });
  }
};
export {
  DatabaseApi
};