@devpad/api 2.0.1 → 2.0.2

package/dist/schema/blog.js

@@ -0,0 +1,348 @@
+import {
+  api_keys
+} from "../chunk-FOO5XXY5.js";
+
+// ../schema/dist/blog/index.js
+import { create_cloudflare_backend, create_corpus, create_memory_backend, define_store as define_store2, err as err2, json_codec as json_codec2, ok as ok2 } from "@f0rbit/corpus";
+
+// ../schema/dist/database/blog.js
+import { sql } from "drizzle-orm";
+import { integer, primaryKey, sqliteTable, text, unique } from "drizzle-orm/sqlite-core";
+var blog_posts = sqliteTable("blog_posts", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  uuid: text("uuid").notNull().unique(),
+  author_id: text("author_id").notNull(),
+  slug: text("slug").notNull(),
+  corpus_version: text("corpus_version"),
+  category: text("category").notNull().default("root"),
+  archived: integer("archived", { mode: "boolean" }).notNull().default(false),
+  publish_at: integer("publish_at", { mode: "timestamp" }),
+  created_at: integer("created_at", { mode: "timestamp" }).notNull().default(sql`(unixepoch())`),
+  updated_at: integer("updated_at", { mode: "timestamp" }).notNull().default(sql`(unixepoch())`)
+}, (table) => ({
+  posts_author_slug_unique: unique("posts_author_slug_unique").on(table.author_id, table.slug)
+}));
+var blog_categories = sqliteTable("blog_categories", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  owner_id: text("owner_id").notNull(),
+  name: text("name").notNull(),
+  parent: text("parent").default("root")
+}, (table) => ({
+  categories_owner_name_unique: unique("categories_owner_name_unique").on(table.owner_id, table.name)
+}));
+var blog_tags = sqliteTable("blog_tags", {
+  post_id: integer("post_id").notNull().references(() => blog_posts.id, { onDelete: "cascade" }),
+  tag: text("tag").notNull()
+}, (table) => ({
+  blog_tags_pk: primaryKey({ columns: [table.post_id, table.tag] })
+}));
+var blog_integrations = sqliteTable("blog_integrations", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  user_id: text("user_id").notNull(),
+  source: text("source").notNull(),
+  location: text("location").notNull(),
+  data: text("data", { mode: "json" }).$type(),
+  last_fetch: integer("last_fetch", { mode: "timestamp" }),
+  status: text("status").default("pending"),
+  created_at: integer("created_at", { mode: "timestamp" }).notNull().default(sql`(unixepoch())`)
+});
+var blog_fetch_links = sqliteTable("blog_fetch_links", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  post_id: integer("post_id").notNull().references(() => blog_posts.id, { onDelete: "cascade" }),
+  integration_id: integer("integration_id").notNull().references(() => blog_integrations.id, { onDelete: "cascade" }),
+  identifier: text("identifier").notNull()
+}, (table) => ({
+  fetch_links_integration_identifier_unique: unique("fetch_links_integration_identifier_unique").on(table.integration_id, table.identifier)
+}));
+var blog_post_projects = sqliteTable("blog_post_projects", {
+  post_id: integer("post_id").notNull().references(() => blog_posts.id, { onDelete: "cascade" }),
+  project_id: text("project_id").notNull(),
+  created_at: integer("created_at", { mode: "timestamp" }).notNull().default(sql`(unixepoch())`)
+}, (table) => ({
+  blog_post_projects_pk: primaryKey({ columns: [table.post_id, table.project_id] })
+}));
+
+// ../schema/dist/blog/corpus.js
+import { define_store, json_codec } from "@f0rbit/corpus";
+import { z } from "zod";
+var PostContentSchema = z.object({
+  title: z.string().min(1),
+  content: z.string(),
+  description: z.string().optional(),
+  format: z.enum(["md", "adoc"])
+});
+var postsStoreDefinition = define_store("posts", json_codec(PostContentSchema));
+var postStoreId = (userId, postUuid) => `posts/${userId}/${postUuid}`;
+var corpusPath = postStoreId;
+var VersionInfoSchema = z.object({
+  hash: z.string(),
+  parent: z.string().nullable(),
+  created_at: z.date()
+});
+var mapCorpusError = (e) => {
+  if (e.kind === "not_found") {
+    return { kind: "not_found", path: e.store_id, version: e.version };
+  }
+  if (e.kind === "decode_error" || e.kind === "validation_error") {
+    return { kind: "invalid_content", message: e.cause?.message ?? "Decode error" };
+  }
+  if (e.kind === "storage_error") {
+    const drizzle_err = e.cause;
+    const underlying = drizzle_err?.cause;
+    const message = underlying?.message ?? drizzle_err?.message ?? "Storage error";
+    return { kind: "io_error", message };
+  }
+  return { kind: "io_error", message: "Unknown corpus error" };
+};
+var parsePostContent = PostContentSchema.parse.bind(PostContentSchema);
+var serializePostContent = (content) => JSON.stringify(content);
+
+// ../schema/dist/blog/corpus-shim.js
+import { at, fetch_result, first, format_error, last, match, pipe, to_fallback, to_nullable, try_catch, try_catch_async, unwrap_or } from "@f0rbit/corpus";
+
+// ../schema/dist/blog/types.js
+import { z as z2 } from "zod";
+import { at as at2, err, fetch_result as fetch_result2, first as first2, format_error as format_error2, last as last2, match as match2, ok, pipe as pipe2, to_fallback as to_fallback2, to_nullable as to_nullable2, try_catch as try_catch2, try_catch_async as try_catch_async2, unwrap_or as unwrap_or2 } from "@f0rbit/corpus";
+var PostRowSchema = z2.object({
+  id: z2.number(),
+  uuid: z2.string(),
+  author_id: z2.string(),
+  slug: z2.string(),
+  corpus_version: z2.string().nullable(),
+  category: z2.string(),
+  archived: z2.boolean(),
+  publish_at: z2.coerce.date().nullable(),
+  created_at: z2.coerce.date(),
+  updated_at: z2.coerce.date()
+});
+var PostRowInsertSchema = z2.object({
+  id: z2.number().optional(),
+  uuid: z2.string(),
+  author_id: z2.string(),
+  slug: z2.string(),
+  corpus_version: z2.string().nullable().optional(),
+  category: z2.string().optional(),
+  archived: z2.boolean().optional(),
+  publish_at: z2.coerce.date().nullable().optional(),
+  created_at: z2.coerce.date().optional(),
+  updated_at: z2.coerce.date().optional()
+});
+var CategorySchema = z2.object({
+  id: z2.number(),
+  owner_id: z2.string(),
+  name: z2.string(),
+  parent: z2.string().nullable()
+});
+var CategoryInsertSchema = z2.object({
+  id: z2.number().optional(),
+  owner_id: z2.string(),
+  name: z2.string(),
+  parent: z2.string().nullable().optional()
+});
+var TagSchema = z2.object({
+  post_id: z2.number(),
+  tag: z2.string()
+});
+var TagInsertSchema = z2.object({
+  post_id: z2.number(),
+  tag: z2.string()
+});
+var AccessKeyRowSchema = z2.object({
+  id: z2.number(),
+  user_id: z2.string(),
+  key_hash: z2.string(),
+  name: z2.string(),
+  note: z2.string().nullable(),
+  enabled: z2.boolean(),
+  created_at: z2.coerce.date()
+});
+var AccessKeySchema = AccessKeyRowSchema.omit({ key_hash: true });
+var AccessKeyInsertSchema = z2.object({
+  id: z2.number().optional(),
+  user_id: z2.string(),
+  key_hash: z2.string(),
+  name: z2.string(),
+  note: z2.string().nullable().optional(),
+  enabled: z2.boolean().optional(),
+  created_at: z2.coerce.date().optional()
+});
+var IntegrationSchema = z2.object({
+  id: z2.number(),
+  user_id: z2.string(),
+  source: z2.string(),
+  location: z2.string(),
+  data: z2.record(z2.unknown()).nullable(),
+  last_fetch: z2.coerce.date().nullable(),
+  status: z2.string().nullable(),
+  created_at: z2.coerce.date()
+});
+var IntegrationInsertSchema = z2.object({
+  id: z2.number().optional(),
+  user_id: z2.string(),
+  source: z2.string(),
+  location: z2.string(),
+  data: z2.record(z2.unknown()).nullable().optional(),
+  last_fetch: z2.coerce.date().nullable().optional(),
+  status: z2.string().nullable().optional(),
+  created_at: z2.coerce.date().optional()
+});
+var FetchLinkSchema = z2.object({
+  id: z2.number(),
+  post_id: z2.number(),
+  integration_id: z2.number(),
+  identifier: z2.string()
+});
+var FetchLinkInsertSchema = z2.object({
+  id: z2.number().optional(),
+  post_id: z2.number(),
+  integration_id: z2.number(),
+  identifier: z2.string()
+});
+var PostSchema = z2.object({
+  id: z2.number(),
+  uuid: z2.string().uuid(),
+  author_id: z2.string(),
+  slug: z2.string(),
+  title: z2.string(),
+  content: z2.string(),
+  description: z2.string().optional(),
+  format: z2.enum(["md", "adoc"]),
+  category: z2.string(),
+  tags: z2.array(z2.string()),
+  archived: z2.boolean(),
+  publish_at: z2.coerce.date().nullable(),
+  created_at: z2.coerce.date(),
+  updated_at: z2.coerce.date(),
+  project_ids: z2.array(z2.string()),
+  corpus_version: z2.string().nullable()
+});
+var SlugPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var PostCreateSchema = z2.object({
+  slug: z2.string().regex(SlugPattern, "Slug must be lowercase alphanumeric with hyphens"),
+  title: z2.string().min(1),
+  content: z2.string(),
+  description: z2.string().optional(),
+  format: z2.enum(["md", "adoc"]).default("md"),
+  category: z2.string().default("root"),
+  tags: z2.array(z2.string()).default([]),
+  publish_at: z2.coerce.date().nullable().optional(),
+  project_ids: z2.array(z2.string()).optional()
+});
+var PostUpdateSchema = z2.object({
+  slug: z2.string().regex(SlugPattern, "Slug must be lowercase alphanumeric with hyphens").optional(),
+  title: z2.string().min(1).optional(),
+  content: z2.string().optional(),
+  description: z2.string().optional(),
+  format: z2.enum(["md", "adoc"]).optional(),
+  category: z2.string().optional(),
+  tags: z2.array(z2.string()).optional(),
+  archived: z2.boolean().optional(),
+  publish_at: z2.coerce.date().nullable().optional(),
+  project_ids: z2.array(z2.string()).optional()
+});
+var PostListParamsSchema = z2.object({
+  category: z2.string().optional(),
+  tag: z2.string().optional(),
+  project: z2.string().optional(),
+  status: z2.enum(["published", "scheduled", "draft", "all"]).default("all"),
+  archived: z2.boolean().default(false),
+  limit: z2.coerce.number().min(1).max(100).default(10),
+  offset: z2.coerce.number().min(0).default(0),
+  sort: z2.enum(["created", "updated", "published"]).default("updated")
+});
+var PostsResponseSchema = z2.object({
+  posts: z2.array(PostSchema),
+  total_posts: z2.number(),
+  total_pages: z2.number(),
+  per_page: z2.number(),
+  current_page: z2.number()
+});
+var isPublished = (post) => post.publish_at !== null && post.publish_at <= /* @__PURE__ */ new Date();
+var isScheduled = (post) => post.publish_at !== null && post.publish_at > /* @__PURE__ */ new Date();
+var isDraft = (post) => post.publish_at === null;
+var postStatus = (post) => {
+  if (isDraft(post))
+    return "draft";
+  if (isScheduled(post))
+    return "scheduled";
+  return "published";
+};
+var CategoryCreateSchema = z2.object({
+  name: z2.string().min(1),
+  parent: z2.string().default("root")
+});
+var AccessKeyCreateSchema = z2.object({
+  name: z2.string().min(1),
+  note: z2.string().optional()
+});
+var AccessKeyUpdateSchema = z2.object({
+  name: z2.string().min(1).optional(),
+  note: z2.string().optional(),
+  enabled: z2.boolean().optional()
+});
+var IntegrationUpsertSchema = z2.object({
+  source: z2.string().min(1),
+  location: z2.string().min(1),
+  data: z2.record(z2.unknown()).optional()
+});
+export {
+  AccessKeyCreateSchema,
+  AccessKeyInsertSchema,
+  AccessKeyRowSchema,
+  AccessKeySchema,
+  AccessKeyUpdateSchema,
+  CategoryCreateSchema,
+  CategoryInsertSchema,
+  CategorySchema,
+  FetchLinkInsertSchema,
+  FetchLinkSchema,
+  IntegrationInsertSchema,
+  IntegrationSchema,
+  IntegrationUpsertSchema,
+  PostContentSchema,
+  PostCreateSchema,
+  PostListParamsSchema,
+  PostRowInsertSchema,
+  PostRowSchema,
+  PostSchema,
+  PostUpdateSchema,
+  PostsResponseSchema,
+  TagInsertSchema,
+  TagSchema,
+  VersionInfoSchema,
+  api_keys,
+  at,
+  blog_categories,
+  blog_fetch_links,
+  blog_integrations,
+  blog_post_projects,
+  blog_posts,
+  blog_tags,
+  corpusPath,
+  create_cloudflare_backend,
+  create_corpus,
+  create_memory_backend,
+  define_store2 as define_store,
+  err2 as err,
+  first,
+  format_error,
+  isDraft,
+  isPublished,
+  isScheduled,
+  json_codec2 as json_codec,
+  last,
+  mapCorpusError,
+  match,
+  ok2 as ok,
+  parsePostContent,
+  pipe,
+  postStatus,
+  postStoreId,
+  postsStoreDefinition,
+  serializePostContent,
+  to_fallback,
+  to_nullable,
+  try_catch,
+  try_catch_async,
+  unwrap_or
+};

package/dist/schema/index.d.ts

@@ -0,0 +1,7 @@
+export { A as ActionType, c as action, E as action_relations, b as api_keys, C as api_keys_relations, l as checklist, n as checklist_item, L as checklist_item_relations, K as checklist_relations, q as codebase_tasks, w as commit_detail, d as deleted, e as entity, j as goal, I as goal_relations, i as id, y as ignore_path, m as milestone, H as milestone_relations, a as owned_entity, o as owner_id, p as project, D as project_relations, s as session, B as session_relations, r as tag, x as tag_config, M as tag_relations, k as task, J as task_relations, v as task_tag, N as task_tag_relations, t as timestamps, G as todoUpdatesRelations, g as todo_updates, f as tracker_result, F as tracker_result_relations, h as update_tracker_relations, u as user, z as user_relations } from '../schema.d-BceDyQED.js';
+export { b as ApiError, A as AuthExpiredError, c as BadRequestError, B as BaseError, C as ConflictError, g as CronError, D as DatabaseError, E as EncryptionError, h as ErrorContext, i as ErrorLogEntry, F as ForbiddenError, G as GithubError, a as NetworkError, N as NotFoundError, P as ParseError, f as ProviderError, R as RateLimitedError, d as ScanError, e as ServiceError, S as StoreError, U as UnauthorizedError, V as ValidationError, W as apiError, T as authExpired, $ as badRequest, j as configureErrorLogging, _ as conflict, Z as dbError, Y as encryptionError, a3 as errors, K as forbidden, a2 as githubError, r as isApiError, q as isAuthExpiredError, w as isBadRequestError, v as isConflictError, u as isDatabaseError, t as isEncryptionError, l as isForbiddenError, z as isGithubError, p as isNetworkError, k as isNotFoundError, s as isParseError, n as isRateLimitedError, I as isRetryableError, y as isScanError, H as isServiceError, o as isStoreError, x as isUnauthorizedError, m as isValidationError, Q as networkError, J as notFound, X as parseError, M as rateLimited, a1 as scanError, O as storeError, a0 as unauthorized, L as validation } from '../errors.d-C73AkrdX.js';
+export { c as Action, R as ApiClientConfig, A as ApiKey, a0 as ApiResponse, a5 as ArrayBufferedQueue, a4 as BufferedQueue, C as CodebaseTask, a9 as ConfigSchema, a3 as ConfigSchemaType, L as GetConfigResult, G as Goal, $ as HistoryAction, I as IgnorePath, p as InsertAction, i as InsertApiKey, q as InsertCodebaseTask, n as InsertGoal, u as InsertIgnorePath, m as InsertMilestone, j as InsertProject, h as InsertSession, l as InsertTag, t as InsertTagConfig, k as InsertTask, o as InsertTaskTag, r as InsertTodoUpdate, s as InsertTrackerResult, g as InsertUser, M as Milestone, W as Nullable, P as Project, D as ProjectConfig, J as ProjectWithTasks, V as RequestOptions, E as SaveConfigRequest, F as SaveTagsRequest, Y as ScanStatus, Z as ScanStatusRequest, _ as ScanUpdate, S as Session, N as TAG_COLOURS, a as Tag, O as TagColor, f as TagConfig, K as TagWithColor, Q as TagWithTypedColor, T as Task, b as TaskTag, X as TaskView, H as TaskWithDetails, d as TodoUpdate, e as TrackerResult, B as UpdateAction, a1 as UpdateData, a2 as UpdateUser, z as UpsertGoal, y as UpsertMilestone, v as UpsertProject, x as UpsertTag, w as UpsertTodo, U as User, af as config_schema, ab as project_config, ac as save_config_request, ad as save_tags_request, a8 as update_action, ae as update_user, ah as upsert_goal, ag as upsert_milestone, a6 as upsert_project, aa as upsert_tag, a7 as upsert_todo } from '../types.d-CoHRMrYJ.js';
+import 'drizzle-orm';
+import 'drizzle-orm/sqlite-core';
+import '@f0rbit/corpus';
+import 'zod';

package/dist/schema/index.js

@@ -0,0 +1,186 @@
+import {
+  ArrayBufferedQueue,
+  ConfigSchema,
+  TAG_COLOURS,
+  config_schema,
+  project_config,
+  save_config_request,
+  save_tags_request,
+  update_action,
+  update_user,
+  upsert_goal,
+  upsert_milestone,
+  upsert_project,
+  upsert_tag,
+  upsert_todo
+} from "../chunk-WTGVONUB.js";
+import {
+  apiError,
+  authExpired,
+  badRequest,
+  configureErrorLogging,
+  conflict,
+  dbError,
+  encryptionError,
+  errors,
+  forbidden,
+  githubError,
+  isApiError,
+  isAuthExpiredError,
+  isBadRequestError,
+  isConflictError,
+  isDatabaseError,
+  isEncryptionError,
+  isForbiddenError,
+  isGithubError,
+  isNetworkError,
+  isNotFoundError,
+  isParseError,
+  isRateLimitedError,
+  isRetryableError,
+  isScanError,
+  isServiceError,
+  isStoreError,
+  isUnauthorizedError,
+  isValidationError,
+  networkError,
+  notFound,
+  parseError,
+  rateLimited,
+  scanError,
+  storeError,
+  unauthorized,
+  validation
+} from "../chunk-5X36WMYQ.js";
+import {
+  action,
+  action_relations,
+  api_keys,
+  api_keys_relations,
+  checklist,
+  checklist_item,
+  checklist_item_relations,
+  checklist_relations,
+  codebase_tasks,
+  commit_detail,
+  deleted,
+  entity,
+  goal,
+  goal_relations,
+  id,
+  ignore_path,
+  milestone,
+  milestone_relations,
+  owned_entity,
+  owner_id,
+  project,
+  project_relations,
+  session,
+  session_relations,
+  tag,
+  tag_config,
+  tag_relations,
+  task,
+  task_relations,
+  task_tag,
+  task_tag_relations,
+  timestamps,
+  todoUpdatesRelations,
+  todo_updates,
+  tracker_result,
+  tracker_result_relations,
+  update_tracker_relations,
+  user,
+  user_relations
+} from "../chunk-FOO5XXY5.js";
+export {
+  ArrayBufferedQueue,
+  ConfigSchema,
+  TAG_COLOURS,
+  action,
+  action_relations,
+  apiError,
+  api_keys,
+  api_keys_relations,
+  authExpired,
+  badRequest,
+  checklist,
+  checklist_item,
+  checklist_item_relations,
+  checklist_relations,
+  codebase_tasks,
+  commit_detail,
+  config_schema,
+  configureErrorLogging,
+  conflict,
+  dbError,
+  deleted,
+  encryptionError,
+  entity,
+  errors,
+  forbidden,
+  githubError,
+  goal,
+  goal_relations,
+  id,
+  ignore_path,
+  isApiError,
+  isAuthExpiredError,
+  isBadRequestError,
+  isConflictError,
+  isDatabaseError,
+  isEncryptionError,
+  isForbiddenError,
+  isGithubError,
+  isNetworkError,
+  isNotFoundError,
+  isParseError,
+  isRateLimitedError,
+  isRetryableError,
+  isScanError,
+  isServiceError,
+  isStoreError,
+  isUnauthorizedError,
+  isValidationError,
+  milestone,
+  milestone_relations,
+  networkError,
+  notFound,
+  owned_entity,
+  owner_id,
+  parseError,
+  project,
+  project_config,
+  project_relations,
+  rateLimited,
+  save_config_request,
+  save_tags_request,
+  scanError,
+  session,
+  session_relations,
+  storeError,
+  tag,
+  tag_config,
+  tag_relations,
+  task,
+  task_relations,
+  task_tag,
+  task_tag_relations,
+  timestamps,
+  todoUpdatesRelations,
+  todo_updates,
+  tracker_result,
+  tracker_result_relations,
+  unauthorized,
+  update_action,
+  update_tracker_relations,
+  update_user,
+  upsert_goal,
+  upsert_milestone,
+  upsert_project,
+  upsert_tag,
+  upsert_todo,
+  user,
+  user_relations,
+  validation
+};