@kyro-cms/admin 0.3.2 → 0.3.5

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

@@ -1,112 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,248 +0,0 @@
-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

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