@kyro-cms/admin 0.1.6 → 0.1.8

package/src/lib/db/schema/sqlite-auth.ts

@@ -0,0 +1,112 @@
+import { sqliteTable, text, integer, index } from "drizzle-orm/sqlite-core";
+
+export const users = sqliteTable("users", {
+  id: text("id").primaryKey(),
+  email: text("email").notNull().unique(),
+  passwordHash: text("password_hash").notNull(),
+  name: text("name"),
+  role: text("role").notNull().default("customer"),
+  tenantId: text("tenant_id"),
+  emailVerified: integer("email_verified", { mode: "boolean" }).default(false),
+  locked: integer("locked", { mode: "boolean" }).default(false),
+  lastLogin: text("last_login"),
+  failedLoginAttempts: integer("failed_login_attempts").default(0),
+  lockedUntil: text("locked_until"),
+  createdAt: text("created_at").notNull(),
+  updatedAt: text("updated_at").notNull(),
+});
+
+export const sessions = sqliteTable(
+  "sessions",
+  {
+    id: text("id").primaryKey(),
+    token: text("token").notNull().unique(),
+    refreshToken: text("refresh_token"),
+    userId: text("user_id")
+      .notNull()
+      .references(() => users.id, { onDelete: "cascade" }),
+    expiresAt: text("expires_at").notNull(),
+    createdAt: text("created_at").notNull(),
+  },
+  (table) => {
+    return {
+      userIdIdx: index("idx_sessions_user_id").on(table.userId),
+      tokenIdx: index("idx_sessions_token").on(table.token),
+      expiresIdx: index("idx_sessions_expires").on(table.expiresAt),
+    };
+  },
+);
+
+export const roles = sqliteTable("roles", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull().unique(),
+  level: integer("level").notNull().default(0),
+  inherits: text("inherits").$type<string[]>(),
+  permissions: text("permissions").$type<string[]>(),
+  isSystem: integer("is_system", { mode: "boolean" }).default(false),
+  description: text("description"),
+  createdAt: text("created_at").notNull(),
+});
+
+export const auditLogs = sqliteTable(
+  "audit_logs",
+  {
+    id: text("id").primaryKey(),
+    action: text("action").notNull(),
+    userId: text("user_id").references(() => users.id, {
+      onDelete: "set null",
+    }),
+    userEmail: text("user_email"),
+    role: text("role"),
+    resource: text("resource").notNull(),
+    ipAddress: text("ip_address"),
+    userAgent: text("user_agent"),
+    success: integer("success", { mode: "boolean" }).notNull(),
+    error: text("error"),
+    metadata: text("metadata").$type<Record<string, unknown>>(),
+    createdAt: text("created_at").notNull(),
+  },
+  (table) => {
+    return {
+      userIdIdx: index("idx_audit_user_id").on(table.userId),
+      actionIdx: index("idx_audit_action").on(table.action),
+      createdAtIdx: index("idx_audit_created_at").on(table.createdAt),
+    };
+  },
+);
+
+export const passwordHistory = sqliteTable(
+  "password_history",
+  {
+    id: text("id").primaryKey(),
+    userId: text("user_id")
+      .notNull()
+      .references(() => users.id, { onDelete: "cascade" }),
+    passwordHash: text("password_hash").notNull(),
+    createdAt: text("created_at").notNull(),
+  },
+  (table) => {
+    return {
+      userIdIdx: index("idx_password_history_user_id").on(table.userId),
+    };
+  },
+);
+
+export const lockouts = sqliteTable("lockouts", {
+  id: text("id").primaryKey(),
+  userId: text("user_id")
+    .notNull()
+    .references(() => users.id, { onDelete: "cascade" }),
+  ipAddress: text("ip_address"),
+  lockedUntil: text("locked_until").notNull(),
+  createdAt: text("created_at").notNull(),
+});
+
+export type User = typeof users.$inferSelect;
+export type NewUser = typeof users.$inferInsert;
+export type Session = typeof sessions.$inferSelect;
+export type NewSession = typeof sessions.$inferInsert;
+export type Role = typeof roles.$inferSelect;
+export type NewRole = typeof roles.$inferInsert;
+export type AuditLog = typeof auditLogs.$inferSelect;
+export type NewAuditLog = typeof auditLogs.$inferInsert;

package/src/lib/db/schema/sqlite-content.ts

@@ -0,0 +1,20 @@
+import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
+
+export const documents = sqliteTable("documents", {
+  id: text("id").primaryKey(),
+  collection: text("collection").notNull(),
+  data: text("data").notNull().$type<Record<string, unknown>>(),
+  createdAt: text("created_at").notNull(),
+  updatedAt: text("updated_at").notNull(),
+});
+
+export const globals = sqliteTable("globals", {
+  slug: text("slug").primaryKey(),
+  data: text("data").notNull().$type<Record<string, unknown>>(),
+  updatedAt: text("updated_at").notNull(),
+});
+
+export type Document = typeof documents.$inferSelect;
+export type NewDocument = typeof documents.$inferInsert;
+export type Global = typeof globals.$inferSelect;
+export type NewGlobal = typeof globals.$inferInsert;

package/src/lib/db/version-adapter.ts

@@ -0,0 +1,248 @@
+import { randomUUID } from "crypto";
+import { diff } from "jsondiffpatch";
+import type {
+  Version,
+  VersionStatus,
+  VersionDiff,
+  CreateVersionOptions,
+  PublishVersionOptions,
+  CompareVersionsOptions,
+  VersionHistoryOptions,
+  VersionAdapter,
+} from "@kyro-cms/core";
+import type { DatabaseAdapter } from "./adapter.js";
+
+const VERSIONS_COLLECTION = "_versions";
+
+export class DataStoreVersionAdapter implements VersionAdapter {
+  constructor(private db: DatabaseAdapter) {}
+
+  async createVersion<T>(
+    options: CreateVersionOptions<T>,
+  ): Promise<Version<T>> {
+    const latest = await this.getLatestVersion(
+      options.collection,
+      options.documentId,
+    );
+    const nextVersion = (latest?.version ?? 0) + 1;
+
+    const versionDoc: Version<T> = {
+      id: randomUUID(),
+      collection: options.collection,
+      documentId: options.documentId,
+      version: nextVersion,
+      status: options.status || "draft",
+      data: options.data,
+      createdBy: options.createdBy,
+      createdAt: new Date(),
+      changeDescription: options.changeDescription,
+    };
+
+    await this.db.create(VERSIONS_COLLECTION, versionDoc);
+    return versionDoc;
+  }
+
+  async getVersion<T>(
+    collection: string,
+    versionId: string,
+  ): Promise<Version<T> | null> {
+    const version = await this.db.findById<Version<T>>(
+      VERSIONS_COLLECTION,
+      versionId,
+    );
+    if (!version || version.collection !== collection) return null;
+    return version;
+  }
+
+  async getVersions<T>(options: VersionHistoryOptions): Promise<Version<T>[]> {
+    const result = await this.db.find<Version<T>>(VERSIONS_COLLECTION, {
+      limit: 100,
+    });
+    const filtered = result.docs
+      .filter(
+        (v: Version<T>) =>
+          v.collection === options.collection &&
+          v.documentId === options.documentId,
+      )
+      .sort((a: Version<T>, b: Version<T>) => b.version - a.version)
+      .slice(
+        options.offset ?? 0,
+        (options.offset ?? 0) + (options.limit ?? 20),
+      );
+    return filtered;
+  }
+
+  async getLatestVersion<T>(
+    collection: string,
+    documentId: string,
+  ): Promise<Version<T> | null> {
+    const versions = await this.getVersions<T>({
+      collection,
+      documentId,
+      limit: 1,
+    });
+    return versions.length > 0 ? versions[0] : null;
+  }
+
+  async getPublishedVersion<T>(
+    collection: string,
+    documentId: string,
+  ): Promise<Version<T> | null> {
+    const versions = await this.getVersions<T>({
+      collection,
+      documentId,
+      limit: 100,
+    });
+    return versions.find((v: Version<T>) => v.status === "published") || null;
+  }
+
+  async publishVersion(options: PublishVersionOptions): Promise<void> {
+    const versions = await this.getVersions({
+      collection: options.collection,
+      documentId: options.documentId,
+      limit: 100,
+    });
+    for (const v of versions) {
+      if (v.status === "published") {
+        const updated = { ...v, status: "draft" as VersionStatus };
+        await this.db.update(VERSIONS_COLLECTION, v.id, updated);
+      }
+    }
+
+    const target = versions.find(
+      (v: Version<unknown>) => v.id === options.versionId,
+    );
+    if (target) {
+      const updated = {
+        ...target,
+        status: "published" as VersionStatus,
+        publishedAt: new Date(),
+      };
+      await this.db.update(VERSIONS_COLLECTION, target.id, updated);
+    }
+  }
+
+  async revertToVersion<T>(options: {
+    collection: string;
+    documentId: string;
+    versionId: string;
+    userId: string;
+  }): Promise<Version<T>> {
+    const target = await this.getVersion<T>(
+      options.collection,
+      options.versionId,
+    );
+    if (!target) {
+      throw new Error("Version not found");
+    }
+
+    return this.createVersion<T>({
+      collection: options.collection,
+      documentId: options.documentId,
+      data: target.data,
+      status: "draft",
+      createdBy: options.userId,
+      changeDescription: `Reverted to version ${target.version}`,
+    });
+  }
+
+  async compareVersions<T>(
+    options: CompareVersionsOptions,
+  ): Promise<VersionDiff[]> {
+    const versions = await this.getVersions<T>({
+      collection: options.collection,
+      documentId: options.documentId,
+      limit: 100,
+    });
+
+    const findVersion = (ref: string | number): Version<T> | undefined => {
+      if (typeof ref === "number") {
+        return versions.find((v) => v.version === ref);
+      }
+      return versions.find((v) => v.id === ref);
+    };
+
+    const versionA = findVersion(options.versionA);
+    const versionB = findVersion(options.versionB);
+
+    if (!versionA || !versionB) {
+      throw new Error("One or both versions not found");
+    }
+
+    const delta = diff(
+      versionA.data as Record<string, unknown>,
+      versionB.data as Record<string, unknown>,
+    );
+    const diffs: VersionDiff[] = [];
+
+    if (!delta) return diffs;
+
+    const walkDelta = (obj: any, path: string = "") => {
+      if (
+        Array.isArray(obj) &&
+        obj[0] !== undefined &&
+        obj[1] !== undefined &&
+        obj.length === 2 &&
+        !Array.isArray(obj[0])
+      ) {
+        diffs.push({
+          field: path || "root",
+          oldValue: obj[0],
+          newValue: obj[1],
+        });
+        return;
+      }
+      if (obj && typeof obj === "object" && obj._t === "a") {
+        for (const [key, value] of Object.entries(obj)) {
+          if (key === "_t") continue;
+          const arrayPath = `${path}[${key.replace(/^_/, "")}]`;
+          if (Array.isArray(value) && value.length >= 2) {
+            diffs.push({
+              field: arrayPath,
+              oldValue: value[0],
+              newValue: value[1],
+            });
+          } else {
+            walkDelta(value, arrayPath);
+          }
+        }
+        return;
+      }
+      for (const [key, value] of Object.entries(obj)) {
+        const fullPath = path ? `${path}.${key}` : key;
+        if (
+          Array.isArray(value) &&
+          value.length === 2 &&
+          !Array.isArray(value[0]) &&
+          !Array.isArray(value[1])
+        ) {
+          diffs.push({
+            field: fullPath,
+            oldValue: value[0],
+            newValue: value[1],
+          });
+        } else if (
+          value &&
+          typeof value === "object" &&
+          !Array.isArray(value)
+        ) {
+          walkDelta(value, fullPath);
+        }
+      }
+    };
+
+    walkDelta(delta);
+    return diffs;
+  }
+
+  async deleteVersions(collection: string, documentId: string): Promise<void> {
+    const versions = await this.getVersions({
+      collection,
+      documentId,
+      limit: 100,
+    });
+    for (const v of versions) {
+      await this.db.delete(VERSIONS_COLLECTION, v.id);
+    }
+  }
+}

package/src/lib/graphql/index.ts

@@ -0,0 +1 @@
+export { executeGraphQL, schemaString } from "./schema";