@oh-my-ghaad/core 0.0.1

package/dist/index.cjs

@@ -0,0 +1,460 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Adapter: () => Adapter,
+  Collection: () => Collection,
+  Engine: () => Engine,
+  appConfigSchema: () => appConfigSchema,
+  repoConfigSchema: () => repoConfigSchema
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/validators.ts
+var import_zod = require("zod");
+var appConfigSchema = import_zod.z.object({
+  appName: import_zod.z.string(),
+  appId: import_zod.z.string(),
+  persisted: import_zod.z.boolean().default(true),
+  persistedTokenKey: import_zod.z.string().default("token"),
+  persistedRepoKey: import_zod.z.string().default("repo"),
+  persistedOwnerKey: import_zod.z.string().default("owner"),
+  persistedAdapterKey: import_zod.z.string().default("adapter")
+});
+var repoConfigSchema = import_zod.z.object({
+  prBasedMutations: import_zod.z.boolean().default(true)
+});
+
+// src/engine.ts
+var storage = typeof window !== "undefined" ? window.localStorage : null;
+var Engine = class {
+  status = "unknown";
+  subscriptions = /* @__PURE__ */ new Set();
+  adapters = [];
+  currentAdapter = null;
+  collections = [];
+  appConfig;
+  repoConfig;
+  collectionItems = {};
+  constructor({
+    appConfig,
+    adapters,
+    collections
+  }) {
+    this.appConfig = appConfig;
+    this.adapters = adapters;
+    this.collections = collections;
+    if (this.adapters.length === 1) {
+      this.setAdapter(this.adapters[0]);
+    }
+    if (this.appConfig.persisted) {
+      const persistedAdapter = storage?.getItem(
+        this.appConfig.persistedAdapterKey || "adapter"
+      );
+      if (persistedAdapter) {
+        const adapter = this.adapters.find(
+          (adapter2) => adapter2.name === persistedAdapter
+        );
+        if (adapter) {
+          this.setAdapter(adapter);
+        }
+      }
+      const persistedToken = storage?.getItem(
+        this.appConfig.persistedTokenKey || "token"
+      );
+      if (persistedToken) {
+        this.setToken(persistedToken);
+      }
+      const persistedRepo = storage?.getItem(
+        this.appConfig.persistedRepoKey || "repo"
+      );
+      if (persistedRepo) {
+        this.getAdapter()?.setRepo(persistedRepo);
+      }
+      const persistedOwner = storage?.getItem(
+        this.appConfig.persistedOwnerKey || "owner"
+      );
+      if (persistedOwner) {
+        this.getAdapter()?.setOwner(persistedOwner);
+      }
+    }
+  }
+  setUnauthorizedHandler(handler) {
+    this.adapters.forEach((adapter) => {
+      adapter.setUnauthorizedHandler(handler);
+    });
+  }
+  subscribe(subscription) {
+    this.subscriptions.add(subscription);
+  }
+  unsubscribe(subscription) {
+    this.subscriptions.delete(subscription);
+  }
+  notifySubscribers() {
+    this.subscriptions.forEach(
+      (subscription) => subscription(this.collections)
+    );
+  }
+  setRepoOwner(owner) {
+    if (this.appConfig.persisted) {
+      storage?.setItem(
+        this.appConfig.persistedOwnerKey || "owner",
+        owner || ""
+      );
+    }
+    this.adapters.forEach((adapter) => {
+      adapter.setOwner(owner);
+    });
+    this.notifySubscribers();
+  }
+  setRepoName(name) {
+    if (this.appConfig.persisted) {
+      storage?.setItem(this.appConfig.persistedRepoKey || "repo", name || "");
+    }
+    this.adapters.forEach((adapter) => {
+      adapter.setRepo(name);
+    });
+    this.notifySubscribers();
+  }
+  getRepoStatus() {
+    return this.status;
+  }
+  getAppConfig() {
+    return this.appConfig;
+  }
+  getRepoConfig() {
+    return this.repoConfig;
+  }
+  async fetchRepoConfig() {
+    const rawConfigString = await this.currentAdapter?.fetchFile("config.json").catch(() => {
+      console.log(
+        "OH My GHaaD: Could not fetch the config file, setting status to empty"
+      );
+    });
+    if (!rawConfigString) {
+      this.status = "empty";
+      throw new Error("No config file found");
+    }
+    const rawConfig = JSON.parse(rawConfigString);
+    const parsedConfig = repoConfigSchema.safeParse(rawConfig);
+    let partialConfig = parsedConfig.data;
+    if (parsedConfig.success) {
+      this.status = "valid";
+    } else {
+      this.status = "invalid";
+    }
+    this.repoConfig = partialConfig;
+    return partialConfig;
+  }
+  async sync() {
+    const [repoConfig, ...fetchedCollectionItems] = await Promise.all([
+      this.fetchRepoConfig().catch((error) => {
+        return {
+          prBasedMutations: false
+        };
+      }),
+      ...this.collections.map(async (collection) => ({
+        collectionId: collection.id,
+        items: await this.fetchCollectionItems(collection.id).catch((error) => {
+          return [];
+        })
+      }))
+    ]);
+    this.notifySubscribers();
+  }
+  getToken() {
+    const currentAdapter = this.getAdapter();
+    if (currentAdapter) {
+      return currentAdapter.token;
+    }
+  }
+  setToken(token) {
+    if (this.appConfig.persisted) {
+      storage?.setItem(
+        this.appConfig.persistedTokenKey || "token",
+        token || ""
+      );
+    }
+    this.adapters.forEach((adapter) => {
+      adapter.setToken(token);
+    });
+    this.notifySubscribers();
+  }
+  getAdapters() {
+    return this.adapters;
+  }
+  setAdapter(adapter) {
+    if (this.appConfig.persisted) {
+      storage?.setItem(
+        this.appConfig.persistedAdapterKey || "adapter",
+        adapter?.name || ""
+      );
+    }
+    this.currentAdapter = adapter;
+    this.notifySubscribers();
+    return this;
+  }
+  getAdapter() {
+    return this.currentAdapter;
+  }
+  getCollections() {
+    return this.collections;
+  }
+  getCollection(collectionLookupValue) {
+    return this.collections.find(
+      (c) => c.id === collectionLookupValue || Object.values(c.names).includes(collectionLookupValue)
+    );
+  }
+  getCollectionItems(collectionLookupValue) {
+    const collection = this.getCollection(collectionLookupValue);
+    if (!collection) {
+      throw new Error("Collection not found");
+    }
+    if (!this.collectionItems[collection.id]) {
+      return [];
+    }
+    return this.collectionItems[collection.id];
+  }
+  async fetchCollectionItems(collectionLookupValue, force = false) {
+    if (!this.currentAdapter) {
+      throw new Error("No adapter selected");
+    }
+    const collection = this.getCollection(collectionLookupValue);
+    if (!collection) {
+      throw new Error("Collection not found");
+    }
+    const rawCollectionItems = await this.currentAdapter.fetchDirectory(
+      `collections/${collection.names.path}`
+    );
+    const collectionItems = rawCollectionItems?.map((item) => {
+      return collection.validator.parse(JSON.parse(item));
+    }) || [];
+    this.collectionItems[collection.id] = collectionItems;
+    this.notifySubscribers();
+    return collectionItems;
+  }
+  async fetchCollectionItem(collectionLookupValue, itemId) {
+    const collection = this.getCollection(collectionLookupValue);
+    if (!collection) {
+      throw new Error("Collection not found");
+    }
+    const rawCollectionItem = await this.currentAdapter.fetchFile(
+      `collections/${collection.names.path}/${itemId}.json`
+    );
+    if (!rawCollectionItem) {
+      return null;
+    }
+    const collectionItem = collection.validator.parse(
+      JSON.parse(rawCollectionItem)
+    );
+    return collectionItem;
+  }
+  async addToCollection(collectionLookupValue, data) {
+    if (!this.currentAdapter) {
+      throw new Error("No adapter selected");
+    }
+    const collection = this.getCollection(collectionLookupValue);
+    if (!collection) {
+      throw new Error("Collection not found");
+    }
+    const rawNewItem = {
+      ...data,
+      id: collection.idFunction()
+    };
+    const item = collection.validator.parse(rawNewItem);
+    let request;
+    request = this.currentAdapter.createFile(
+      `collections/${collection.names.path}/${item.id}.json`,
+      JSON.stringify(item, null, 2),
+      `Add ${collection.names.singular} ${item.id}`
+    );
+    return request.then(() => {
+      this.collectionItems[collection.id] = [
+        ...this.collectionItems[collection.id] || [],
+        item
+      ];
+      return this.collectionItems[collection.id];
+    });
+  }
+  async removeFromCollection(collectionLookupValue, itemId) {
+    if (!this.currentAdapter) {
+      throw new Error("No adapter selected");
+    }
+    const collection = this.getCollection(collectionLookupValue);
+    if (!collection) {
+      throw new Error("Collection not found");
+    }
+    let request;
+    request = this.currentAdapter.deleteFile(
+      `collections/${collection.names.path}/${itemId}.json`,
+      `Remove ${collection.names.singular} ${itemId}`
+    );
+    await request.then(() => {
+      this.collectionItems[collection.id] = this.collectionItems[collection.id]?.filter(
+        (item) => item.id !== itemId
+      ) || [];
+      return this.collectionItems[collection.id];
+    });
+    this.notifySubscribers();
+    return this.collectionItems[collection.id];
+  }
+  async updateInCollection(collectionLookupValue, itemId, data) {
+    if (!this.currentAdapter) {
+      throw new Error("No adapter selected");
+    }
+    const collection = this.getCollection(collectionLookupValue);
+    if (!collection) {
+      throw new Error("Collection not found");
+    }
+    const existingItem = this.collectionItems[collection.id].find(
+      (item2) => item2.id === itemId
+    );
+    if (!existingItem) {
+      throw new Error("Item not found");
+    }
+    const item = collection.validator.parse(data);
+    await this.currentAdapter.updateFile(
+      `collections/${collection.names.path}/${itemId}.json`,
+      JSON.stringify(
+        {
+          ...item,
+          id: itemId
+        },
+        null,
+        2
+      ),
+      `Update ${collection.names.singular} ${itemId}`
+    );
+    this.collectionItems[collection.id] = this.collectionItems[collection.id].map((_item) => {
+      if (_item.id === itemId) {
+        return item;
+      }
+      return _item;
+    });
+    this.notifySubscribers();
+    return this.collectionItems[collection.id];
+  }
+  async initializeCollection(collection) {
+    const adapter = this.getAdapter();
+    if (!adapter) {
+      throw new Error("No adapter selected");
+    }
+    return adapter.createFile(
+      `collections/${collection.names.path}/.gitkeep`,
+      "",
+      `Create collection: ${collection.names.singular}`
+    );
+  }
+  async initializeRepoConfig(repoConfig) {
+    const adapter = this.getAdapter();
+    if (!adapter) {
+      throw new Error("No adapter selected");
+    }
+    return adapter.createFile(
+      "config.json",
+      JSON.stringify(
+        repoConfig ?? {
+          prBasedMutations: false
+        }
+      )
+    );
+  }
+  async initialize() {
+    const repoConfig = this.getRepoConfig();
+    await this.initializeRepoConfig(repoConfig);
+    for (const collection of this.collections) {
+      await this.initializeCollection(collection);
+    }
+    this.status = "valid";
+    this.notifySubscribers();
+  }
+  // Grouping together props and methods for caching PRs
+  lastFetchPullRequestTimestamp = 0;
+  cachedPullRequests = [];
+  async fetchPullRequests(force = false) {
+    const adapter = this.getAdapter();
+    if (!adapter) {
+      throw new Error("No adapter selected");
+    }
+    if (force) {
+      this.lastFetchPullRequestTimestamp = 0;
+    }
+    if (this.lastFetchPullRequestTimestamp > Date.now() - 1e3 * 60 * 5) {
+      return this.cachedPullRequests;
+    } else {
+      return adapter.fetchPullRequests();
+    }
+  }
+};
+
+// src/collection.ts
+var Collection = class {
+  id;
+  idFunction;
+  names;
+  validator;
+  constructor({
+    id,
+    idFunction,
+    names,
+    validator
+  }) {
+    this.id = id;
+    this.idFunction = idFunction;
+    this.names = names;
+    this.validator = validator;
+  }
+};
+
+// src/adapter.ts
+var Adapter = class {
+  clientId;
+  redirectUri;
+  token;
+  owner;
+  repo;
+  accessManagementUrl;
+  unauthorizedHandler = null;
+  constructor(props) {
+    this.clientId = props.clientId;
+    this.redirectUri = props.redirectUri;
+    this.accessManagementUrl = props.accessManagementUrl;
+  }
+  setOwner(owner) {
+    this.owner = owner;
+  }
+  setRepo(repo) {
+    this.repo = repo;
+  }
+  setToken(token) {
+    this.token = token;
+  }
+  setUnauthorizedHandler(handler) {
+    this.unauthorizedHandler = handler;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Adapter,
+  Collection,
+  Engine,
+  appConfigSchema,
+  repoConfigSchema
+});

package/dist/index.d.cts

@@ -0,0 +1,187 @@
+import { ZodType, z } from 'zod';
+
+interface CollectionNames {
+    singular: string;
+    plural: string;
+    path: string;
+}
+declare class Collection {
+    id: string;
+    idFunction: () => string;
+    names: CollectionNames;
+    validator: ZodType;
+    constructor({ id, idFunction, names, validator, }: {
+        id: string;
+        idFunction: () => string;
+        names: CollectionNames;
+        validator: ZodType;
+    });
+}
+
+type ValidRepoStatus = "valid" | "pending" | "empty";
+type InvalidRepoStatus = "invalid" | "unknown";
+type RepoStatus = ValidRepoStatus | InvalidRepoStatus;
+type CollectionStatus = "uninitialized" | "valid";
+type CollectionItemStatus = "pending" | "valid" | "invalid";
+type PendingCollectionItemType = "create" | "update" | "delete";
+interface AdapterProps {
+    clientId: string;
+    redirectUri: string;
+    accessManagementUrl: string;
+}
+type Subscription = (collections: Collection[]) => void | Promise<void>;
+interface RepositoryResponse {
+    id: string;
+    org: string;
+    name: string;
+    url: string;
+}
+interface PrResponse {
+    id: string;
+    title: string;
+    description: string;
+    commitSha?: string;
+    createdAt: string;
+}
+type PrRequest = Omit<PrResponse, "id" | "createdAt">;
+interface CommitResponse {
+    commitSha: string;
+    message: string;
+    commitDate: string;
+    authorName: string;
+    authorImageUrl: string;
+}
+type CommitRequest = Pick<CommitResponse, "message">;
+interface IAdapter extends AdapterProps {
+    readonly name: string;
+    readonly icon: string;
+    readonly primaryColor: string;
+    readonly secondaryColor: string;
+    readonly oauthUrl: string;
+    readonly baseUrl: string;
+    fetchRepositories(): Promise<RepositoryResponse[]>;
+    fetchFile(filePath: string): Promise<string>;
+    fetchFileHistory(filePath: string): Promise<CommitResponse[]>;
+    fetchDirectory(directoryPath: string): Promise<string[]>;
+    createCommit(commitRequest: CommitRequest): Promise<void>;
+    createFile(filePath: string, content: string, message?: string): Promise<void>;
+    updateFile(filePath: string, content: string, message?: string): Promise<void>;
+    deleteFile(filePath: string, message?: string): Promise<void>;
+    fetchPullRequests(): Promise<PrResponse[]>;
+    createPullRequest(prRequest: PrRequest): Promise<void>;
+    fetchPullRequest(): Promise<PrResponse>;
+    updatePullRequest(prRequest: PrRequest): Promise<void>;
+    deletePullRequest(id: string): Promise<void>;
+}
+interface BaseCollectionItem {
+    id: string;
+    fileName: string;
+}
+
+declare class Adapter implements AdapterProps {
+    clientId: string;
+    redirectUri: string;
+    token: string | null;
+    owner: string | null;
+    repo: string | null;
+    accessManagementUrl: string;
+    protected unauthorizedHandler: (() => void | Promise<void>) | null;
+    constructor(props: AdapterProps);
+    setOwner(owner: string | null): void;
+    setRepo(repo: string | null): void;
+    setToken(token: string | null): void;
+    setUnauthorizedHandler(handler: () => void | Promise<void>): void;
+}
+
+declare const appConfigSchema: z.ZodObject<{
+    appName: z.ZodString;
+    appId: z.ZodString;
+    persisted: z.ZodDefault<z.ZodBoolean>;
+    persistedTokenKey: z.ZodDefault<z.ZodString>;
+    persistedRepoKey: z.ZodDefault<z.ZodString>;
+    persistedOwnerKey: z.ZodDefault<z.ZodString>;
+    persistedAdapterKey: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    appName?: string;
+    appId?: string;
+    persisted?: boolean;
+    persistedTokenKey?: string;
+    persistedRepoKey?: string;
+    persistedOwnerKey?: string;
+    persistedAdapterKey?: string;
+}, {
+    appName?: string;
+    appId?: string;
+    persisted?: boolean;
+    persistedTokenKey?: string;
+    persistedRepoKey?: string;
+    persistedOwnerKey?: string;
+    persistedAdapterKey?: string;
+}>;
+type AppConfig = z.infer<typeof appConfigSchema>;
+declare const repoConfigSchema: z.ZodObject<{
+    prBasedMutations: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    prBasedMutations?: boolean;
+}, {
+    prBasedMutations?: boolean;
+}>;
+type RepoConfig = z.infer<typeof repoConfigSchema> & {
+    status: RepoStatus;
+};
+
+declare class Engine {
+    private status;
+    private subscriptions;
+    private adapters;
+    private currentAdapter;
+    private collections;
+    private appConfig;
+    private repoConfig;
+    private collectionItems;
+    constructor({ appConfig, adapters, collections, }: {
+        adapters: (Adapter & IAdapter)[];
+        collections: Collection[];
+        appConfig: AppConfig;
+    });
+    setUnauthorizedHandler(handler: () => void | Promise<void>): void;
+    subscribe(subscription: Subscription): void;
+    unsubscribe(subscription: Subscription): void;
+    private notifySubscribers;
+    setRepoOwner(owner: string | null): void;
+    setRepoName(name: string | null): void;
+    getRepoStatus(): RepoStatus;
+    getAppConfig(): {
+        appName?: string;
+        appId?: string;
+        persisted?: boolean;
+        persistedTokenKey?: string;
+        persistedRepoKey?: string;
+        persistedOwnerKey?: string;
+        persistedAdapterKey?: string;
+    };
+    getRepoConfig(): RepoConfig;
+    fetchRepoConfig(): Promise<RepoConfig>;
+    sync(): Promise<void>;
+    getToken(): string;
+    setToken(token: string | null): void;
+    getAdapters(): (Adapter & IAdapter)[];
+    setAdapter(adapter: (Adapter & IAdapter) | null): this;
+    getAdapter(): Adapter & IAdapter;
+    getCollections(): Collection[];
+    getCollection<T extends Collection>(collectionLookupValue: T["id"] | T["names"]["singular"] | T["names"]["plural"]): Collection | undefined;
+    getCollectionItems<T extends Collection>(collectionLookupValue: T["id"] | T["names"]["singular"] | T["names"]["plural"]): z.infer<T["validator"]>[];
+    fetchCollectionItems<T extends Collection>(collectionLookupValue: T["id"] | T["names"]["singular"] | T["names"]["plural"], force?: boolean): Promise<z.infer<T["validator"]>[]>;
+    fetchCollectionItem<T extends Collection>(collectionLookupValue: T["id"] | T["names"]["singular"] | T["names"]["plural"], itemId: z.infer<T["validator"]>["id"]): Promise<z.infer<T["validator"]> | null>;
+    addToCollection<T extends Collection>(collectionLookupValue: T["id"] | T["names"]["singular"] | T["names"]["plural"], data: z.infer<T["validator"]>): Promise<z.infer<T["validator"]>[]>;
+    removeFromCollection<T extends Collection>(collectionLookupValue: T["id"] | T["names"]["singular"] | T["names"]["plural"], itemId: z.infer<T["validator"]>["id"]): Promise<z.infer<T["validator"]>[]>;
+    updateInCollection<T extends Collection>(collectionLookupValue: T["id"] | T["names"]["singular"] | T["names"]["plural"], itemId: string, data: z.infer<T["validator"]>): Promise<z.infer<T["validator"]>[]>;
+    initializeCollection(collection: Collection): Promise<void>;
+    initializeRepoConfig(repoConfig: RepoConfig): Promise<void>;
+    initialize(): Promise<void>;
+    private lastFetchPullRequestTimestamp;
+    private cachedPullRequests;
+    fetchPullRequests(force?: boolean): Promise<PrResponse[]>;
+}
+
+export { Adapter, type AdapterProps, type AppConfig, type BaseCollectionItem, Collection, type CollectionItemStatus, type CollectionStatus, type CommitRequest, type CommitResponse, Engine, type IAdapter, type InvalidRepoStatus, type PendingCollectionItemType, type PrRequest, type PrResponse, type RepoConfig, type RepoStatus, type RepositoryResponse, type Subscription, type ValidRepoStatus, appConfigSchema, repoConfigSchema };