gomtm 0.0.8 → 0.0.10

package/dist/esm/gomtmpb/mtm/sppb/mtm_pb.d.ts

@@ -537,6 +537,7 @@ export declare class ListParams extends Message<ListParams> {
 }
 export declare class CommentListReq extends Message<CommentListReq> {
     params?: ListParams;
+    pagination?: Paging;
     constructor(data?: PartialMessage<CommentListReq>);
     static readonly runtime: typeof proto3;
     static readonly typeName = "sppb.CommentListReq";

package/dist/esm/gomtmpb/mtm/sppb/mtm_pb.js

@@ -2141,6 +2141,10 @@ const _CommentListReq = class _CommentListReq extends Message {
      * @generated from field: sppb.ListParams params = 1;
      */
     __publicField(this, "params");
+    /**
+     * @generated from field: sppb.Paging pagination = 2;
+     */
+    __publicField(this, "pagination");
     proto3.util.initPartial(data, this);
   }
   static fromBinary(bytes, options) {
@@ -2159,7 +2163,8 @@ const _CommentListReq = class _CommentListReq extends Message {
 __publicField(_CommentListReq, "runtime", proto3);
 __publicField(_CommentListReq, "typeName", "sppb.CommentListReq");
 __publicField(_CommentListReq, "fields", proto3.util.newFieldList(() => [
-  { no: 1, name: "params", kind: "message", T: ListParams }
+  { no: 1, name: "params", kind: "message", T: ListParams },
+  { no: 2, name: "pagination", kind: "message", T: Paging }
 ]));
 let CommentListReq = _CommentListReq;
 const _CommentListRes = class _CommentListRes extends Message {

package/dist/esm/index.d.ts

@@ -1,2 +1 @@
-export type { PlainMessage } from "@bufbuild/protobuf";
-export declare const hellogomtm: () => void;
+export type * from "@bufbuild/protobuf";

package/dist/esm/index.js

@@ -1,5 +0,0 @@
-const hellogomtm = () => {
-};
-export {
-  hellogomtm
-};

package/dist/esm/jotai-helper.d.ts

@@ -0,0 +1,23 @@
+import { createStore, Getter, SetStateAction, Setter, WritableAtom } from 'jotai';
+import { ReactNode } from 'react';
+export declare function AtomsHydrator({ atomValues, store, children, }: {
+    atomValues: Iterable<readonly [WritableAtom<unknown, [any], unknown>, unknown]>;
+    store?: ReturnType<typeof createStore>;
+    children: ReactNode;
+}): ReactNode;
+export default function atomWithDebounce<T>(initialValue: T, delayMilliseconds?: number, shouldDebounceOnReset?: boolean): {
+    currentValueAtom: import("jotai").Atom<T>;
+    isDebouncingAtom: import("jotai").PrimitiveAtom<boolean> & {
+        init: boolean;
+    };
+    clearTimeoutAtom: WritableAtom<null, [_arg: unknown], void> & {
+        init: null;
+    };
+    debouncedValueAtom: WritableAtom<T, [update: SetStateAction<T>], void> & {
+        init: T;
+    };
+};
+export declare function atomWithRefresh<T>(fn: (get: Getter) => T): WritableAtom<T, [], void>;
+type Callback<Value> = (get: Getter, set: Setter, newVal: Value, prevVal: Value) => void;
+export declare function atomWithListeners<Value>(initialValue: Value): readonly [WritableAtom<Value, [arg: SetStateAction<Value>], void>, (callback: Callback<Value>) => void];
+export {};

package/dist/esm/jotai-helper.js

@@ -0,0 +1,96 @@
+"use client";
+import { atom, useSetAtom } from "jotai";
+import { useHydrateAtoms } from "jotai/utils";
+import { useEffect } from "react";
+function AtomsHydrator({
+  atomValues,
+  store,
+  children
+}) {
+  useHydrateAtoms(new Map(atomValues), { store });
+  return children;
+}
+function atomWithDebounce(initialValue, delayMilliseconds = 500, shouldDebounceOnReset = false) {
+  const prevTimeoutAtom = atom(
+    void 0
+  );
+  const _currentValueAtom = atom(initialValue);
+  const isDebouncingAtom = atom(false);
+  const debouncedValueAtom = atom(
+    initialValue,
+    (get, set, update) => {
+      clearTimeout(get(prevTimeoutAtom));
+      const prevValue = get(_currentValueAtom);
+      const nextValue = typeof update === "function" ? update(prevValue) : update;
+      const onDebounceStart = () => {
+        set(_currentValueAtom, nextValue);
+        set(isDebouncingAtom, true);
+      };
+      const onDebounceEnd = () => {
+        set(debouncedValueAtom, nextValue);
+        set(isDebouncingAtom, false);
+      };
+      onDebounceStart();
+      if (!shouldDebounceOnReset && nextValue === initialValue) {
+        onDebounceEnd();
+        return;
+      }
+      const nextTimeoutId = setTimeout(() => {
+        onDebounceEnd();
+      }, delayMilliseconds);
+      set(prevTimeoutAtom, nextTimeoutId);
+    }
+  );
+  const clearTimeoutAtom = atom(null, (get, set, _arg) => {
+    clearTimeout(get(prevTimeoutAtom));
+    set(isDebouncingAtom, false);
+  });
+  return {
+    currentValueAtom: atom((get) => get(_currentValueAtom)),
+    isDebouncingAtom,
+    clearTimeoutAtom,
+    debouncedValueAtom
+  };
+}
+function atomWithRefresh(fn) {
+  const refreshCounter = atom(0);
+  return atom(
+    (get) => {
+      get(refreshCounter);
+      return fn(get);
+    },
+    (_, set) => set(refreshCounter, (i) => i + 1)
+  );
+}
+function atomWithListeners(initialValue) {
+  const baseAtom = atom(initialValue);
+  const listenersAtom = atom([]);
+  const anAtom = atom(
+    (get) => get(baseAtom),
+    (get, set, arg) => {
+      const prevVal = get(baseAtom);
+      set(baseAtom, arg);
+      const newVal = get(baseAtom);
+      get(listenersAtom).forEach((callback) => {
+        callback(get, set, newVal, prevVal);
+      });
+    }
+  );
+  const useListener = (callback) => {
+    const setListeners = useSetAtom(listenersAtom);
+    useEffect(() => {
+      setListeners((prev) => [...prev, callback]);
+      return () => setListeners((prev) => {
+        const index = prev.indexOf(callback);
+        return [...prev.slice(0, index), ...prev.slice(index + 1)];
+      });
+    }, [setListeners, callback]);
+  };
+  return [anAtom, useListener];
+}
+export {
+  AtomsHydrator,
+  atomWithListeners,
+  atomWithRefresh,
+  atomWithDebounce as default
+};

package/dist/esm/validations/CrawlerConfig.d.ts

@@ -0,0 +1,18 @@
+import * as z from "zod";
+export declare const crawlerConfigSchema: z.ZodObject<{
+    entryUrls: z.ZodString;
+    proxy: z.ZodOptional<z.ZodString>;
+    maxRequestsPerCrawl: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    queueName: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    entryUrls: string;
+    proxy?: string | undefined;
+    maxRequestsPerCrawl?: number | undefined;
+    queueName?: string | undefined;
+}, {
+    entryUrls: string;
+    proxy?: string | undefined;
+    maxRequestsPerCrawl?: number | undefined;
+    queueName?: string | undefined;
+}>;
+export type CrawlerConfigType = z.infer<typeof crawlerConfigSchema>;

package/dist/esm/validations/CrawlerConfig.js

@@ -0,0 +1,10 @@
+import * as z from "zod";
+const crawlerConfigSchema = z.object({
+  entryUrls: z.string(),
+  proxy: z.string().optional(),
+  maxRequestsPerCrawl: z.number().default(1e3).optional(),
+  queueName: z.string().optional()
+});
+export {
+  crawlerConfigSchema
+};

package/dist/esm/validations/_common.d.ts

@@ -0,0 +1,57 @@
+import { z } from "zod";
+export type Literal = boolean | number | string;
+export type Json = Literal | {
+    [key: string]: Json;
+} | Json[];
+export declare const literalSchema: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+export declare const jsonSchema: z.ZodSchema<Json>;
+export declare const commonListInputSchema: z.ZodObject<{
+    keyword: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    keyword?: string | undefined;
+    limit?: number | undefined;
+    cursor?: string | null | undefined;
+}, {
+    keyword?: string | undefined;
+    limit?: number | undefined;
+    cursor?: string | null | undefined;
+}>;
+export declare const getByIdInputSchema: z.ZodObject<{
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+}, {
+    id: string;
+}>;
+export declare const EntityItemBaseSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+}, "strip", z.ZodTypeAny, {
+    id?: string | number | undefined;
+}, {
+    id?: string | number | undefined;
+}>;
+export type EntityBaseItem = z.infer<typeof EntityItemBaseSchema>;
+export declare const deleteByIdSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+}, "strip", z.ZodTypeAny, {
+    id?: string | number | undefined;
+}, {
+    id?: string | number | undefined;
+}>;
+export interface ComponentWithViewType {
+    viewType: {
+        name: string;
+    };
+}
+export declare const PaginateQuery: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    limit?: number | undefined;
+    cursor?: string | null | undefined;
+}, {
+    limit?: number | undefined;
+    cursor?: string | null | undefined;
+}>;

package/dist/esm/validations/_common.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+const literalSchema = z.union([z.string(), z.number(), z.boolean()]);
+const jsonSchema = z.lazy(() => z.union([literalSchema, z.array(jsonSchema), z.record(jsonSchema)]));
+const commonListInputSchema = z.object({
+  keyword: z.string().optional(),
+  limit: z.number().min(1).max(100).optional(),
+  cursor: z.string().nullish()
+});
+const getByIdInputSchema = z.object({
+  id: z.string()
+});
+const EntityItemBaseSchema = z.object({
+  id: z.string().or(z.number()).optional()
+});
+const deleteByIdSchema = z.object({
+  id: z.string().or(z.number()).optional()
+});
+const PaginateQuery = z.object({
+  limit: z.number().min(1).max(1e3).optional(),
+  cursor: z.string().nullish()
+});
+export {
+  EntityItemBaseSchema,
+  PaginateQuery,
+  commonListInputSchema,
+  deleteByIdSchema,
+  getByIdInputSchema,
+  jsonSchema,
+  literalSchema
+};

package/dist/esm/validations/auth.d.ts

@@ -0,0 +1,33 @@
+import * as z from "zod";
+export declare const userAuthSchema: z.ZodObject<{
+    email: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+}, {
+    email: string;
+}>;
+export type AuthLoginInput = z.infer<typeof AuthLoginInput>;
+export declare const AuthLoginInput: z.ZodObject<{
+    username: z.ZodString;
+    password: z.ZodString;
+    persistent: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    username: string;
+    password: string;
+    persistent?: boolean | undefined;
+}, {
+    username: string;
+    password: string;
+    persistent?: boolean | undefined;
+}>;
+export type AuthLoginOut = z.infer<typeof AuthLoginOut>;
+export declare const AuthLoginOut: z.ZodObject<{
+    ok: z.ZodBoolean;
+    token: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    ok: boolean;
+    token?: string | undefined;
+}, {
+    ok: boolean;
+    token?: string | undefined;
+}>;

package/dist/esm/validations/auth.js

@@ -0,0 +1,18 @@
+import * as z from "zod";
+const userAuthSchema = z.object({
+  email: z.string().email()
+});
+const AuthLoginInput = z.object({
+  username: z.string(),
+  password: z.string(),
+  persistent: z.boolean().optional()
+});
+const AuthLoginOut = z.object({
+  ok: z.boolean(),
+  token: z.string().optional()
+});
+export {
+  AuthLoginInput,
+  AuthLoginOut,
+  userAuthSchema
+};

package/dist/esm/validations/blog.d.ts

@@ -0,0 +1,17 @@
+import * as z from "zod";
+export declare const blogListQueryInputSchema: z.ZodObject<{
+    keyword: z.ZodOptional<z.ZodString>;
+    slug: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    keyword?: string | undefined;
+    slug?: string | undefined;
+    limit?: number | undefined;
+    cursor?: string | null | undefined;
+}, {
+    keyword?: string | undefined;
+    slug?: string | undefined;
+    limit?: number | undefined;
+    cursor?: string | null | undefined;
+}>;

package/dist/esm/validations/blog.js

@@ -0,0 +1,10 @@
+import * as z from "zod";
+const blogListQueryInputSchema = z.object({
+  keyword: z.string().optional(),
+  slug: z.string().optional(),
+  limit: z.number().min(1).max(1e3).optional(),
+  cursor: z.string().nullish()
+});
+export {
+  blogListQueryInputSchema
+};

package/dist/esm/validations/crawlerSchema.d.ts

@@ -0,0 +1,17 @@
+import * as z from "zod";
+export declare const crawlerListQueryInputSchema: z.ZodObject<{
+    q: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    q?: string | undefined;
+    name?: string | undefined;
+    cursor?: string | undefined;
+}, {
+    q?: string | undefined;
+    name?: string | undefined;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+}>;

package/dist/esm/validations/crawlerSchema.js

@@ -0,0 +1,10 @@
+import * as z from "zod";
+const crawlerListQueryInputSchema = z.object({
+  q: z.string().optional(),
+  name: z.string().optional(),
+  limit: z.number().default(12),
+  cursor: z.string().optional()
+});
+export {
+  crawlerListQueryInputSchema
+};

package/dist/esm/validations/env.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const env: z.SafeParseReturnType<{
+    DATABASE_URL: string;
+    NODE_ENV: "development" | "test" | "production";
+}, {
+    DATABASE_URL: string;
+    NODE_ENV: "development" | "test" | "production";
+}>;

package/dist/esm/validations/env.js

@@ -0,0 +1,9 @@
+import { z } from "zod";
+const envSchema = z.object({
+  DATABASE_URL: z.string().url(),
+  NODE_ENV: z.enum(["development", "test", "production"])
+});
+const env = envSchema.safeParse(process.env);
+export {
+  env
+};

package/dist/esm/validations/post.d.ts

@@ -0,0 +1,34 @@
+import * as z from "zod";
+export declare const postPatchSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    title?: string | undefined;
+    content?: any;
+}, {
+    title?: string | undefined;
+    content?: any;
+}>;
+export declare const postListQueryInputSchema: z.ZodObject<{
+    q: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    q?: string | undefined;
+}, {
+    q?: string | undefined;
+}>;
+export declare const createPostSchema: z.ZodObject<{
+    appId: z.ZodString;
+    title: z.ZodString;
+    content: z.ZodString;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    content: string;
+    appId: string;
+    tags?: string[] | undefined;
+}, {
+    title: string;
+    content: string;
+    appId: string;
+    tags?: string[] | undefined;
+}>;

package/dist/esm/validations/post.js

@@ -0,0 +1,28 @@
+import * as z from "zod";
+const postPatchSchema = z.object({
+  title: z.string().min(3).max(128).optional(),
+  // TODO: Type this properly from editorjs block types?
+  content: z.any().optional()
+});
+const postListQueryInputSchema = z.object({
+  q: z.string().optional()
+  // siteId: z.string().optional(),
+  // categoryId: z.number().optional(),
+  // slug: z.string().optional(),
+  // tags: z.string().optional(),
+  // limit: z.number().min(1).max(100).optional(),
+  // cursor: z.string().nullish(),
+});
+const createPostSchema = z.object({
+  // blogId: z.string(),
+  appId: z.string(),
+  // categoryId: z.string(),
+  title: z.string(),
+  content: z.string(),
+  tags: z.array(z.string()).optional()
+});
+export {
+  createPostSchema,
+  postListQueryInputSchema,
+  postPatchSchema
+};

package/dist/esm/validations/sp.d.ts

@@ -0,0 +1,18 @@
+import * as z from "zod";
+export declare const spHandleBySlugsInput: z.ZodObject<{
+    domain: z.ZodString;
+    url: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    domain: string;
+}, {
+    url: string;
+    domain: string;
+}>;
+export declare const spImportDataInput: z.ZodObject<{
+    jsonData: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    jsonData: string;
+}, {
+    jsonData: string;
+}>;

package/dist/esm/validations/sp.js

@@ -0,0 +1,12 @@
+import * as z from "zod";
+const spHandleBySlugsInput = z.object({
+  domain: z.string(),
+  url: z.string()
+});
+const spImportDataInput = z.object({
+  jsonData: z.string()
+});
+export {
+  spHandleBySlugsInput,
+  spImportDataInput
+};

package/dist/esm/validations/spContentModi.d.ts

@@ -0,0 +1,62 @@
+import { z } from "zod";
+export declare const spContentModiListInput: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodOptional<z.ZodObject<{
+    spRouteId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    spRouteId?: string | undefined;
+}, {
+    spRouteId?: string | undefined;
+}>>>>>;
+export declare const spContentModiGetInput: z.ZodObject<{
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+}, {
+    id: string;
+}>;
+export declare const spContentModiCreateInput: z.ZodObject<{
+    spRouteId: z.ZodString;
+    matchContentType: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    sel: z.ZodString;
+    action: z.ZodString;
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    action: string;
+    sel: string;
+    spRouteId: string;
+    matchContentType: string;
+    title?: string | undefined;
+}, {
+    value: string;
+    action: string;
+    sel: string;
+    spRouteId: string;
+    matchContentType: string;
+    title?: string | undefined;
+}>;
+export declare const spContentModiSaveInput: z.ZodObject<{
+    id: z.ZodString;
+    matchContentType: z.ZodString;
+    spRouteId: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    sel: z.ZodString;
+    action: z.ZodString;
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    value: string;
+    action: string;
+    sel: string;
+    spRouteId: string;
+    matchContentType: string;
+    title?: string | undefined;
+}, {
+    id: string;
+    value: string;
+    action: string;
+    sel: string;
+    spRouteId: string;
+    matchContentType: string;
+    title?: string | undefined;
+}>;

package/dist/esm/validations/spContentModi.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+const spContentModiListInput = z.object({
+  spRouteId: z.string().optional()
+}).optional().nullable().nullish();
+const spContentModiGetInput = z.object({
+  id: z.string()
+});
+const spContentModiCreateInput = z.object({
+  spRouteId: z.string(),
+  matchContentType: z.string(),
+  title: z.string().optional(),
+  sel: z.string(),
+  action: z.string(),
+  value: z.string()
+});
+const spContentModiSaveInput = z.object({
+  id: z.string(),
+  matchContentType: z.string(),
+  spRouteId: z.string(),
+  title: z.string().optional(),
+  sel: z.string(),
+  action: z.string(),
+  value: z.string()
+});
+export {
+  spContentModiCreateInput,
+  spContentModiGetInput,
+  spContentModiListInput,
+  spContentModiSaveInput
+};

package/dist/esm/validations/spHost.d.ts

@@ -0,0 +1,8 @@
+import * as z from "zod";
+export declare const spHostGetHostInput: z.ZodObject<{
+    host: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    host?: string | undefined;
+}, {
+    host?: string | undefined;
+}>;

package/dist/esm/validations/spHost.js

@@ -0,0 +1,7 @@
+import * as z from "zod";
+const spHostGetHostInput = z.object({
+  host: z.string().optional()
+});
+export {
+  spHostGetHostInput
+};

package/dist/esm/validations/spPage.d.ts

@@ -0,0 +1,14 @@
+import * as z from "zod";
+export declare const spPageGetBySlugsInput: z.ZodObject<{
+    host: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+    searchParams: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    host?: string | undefined;
+    path?: string | undefined;
+    searchParams?: string | undefined;
+}, {
+    host?: string | undefined;
+    path?: string | undefined;
+    searchParams?: string | undefined;
+}>;

package/dist/esm/validations/spPage.js

@@ -0,0 +1,9 @@
+import * as z from "zod";
+const spPageGetBySlugsInput = z.object({
+  host: z.string().optional(),
+  path: z.string().optional(),
+  searchParams: z.string().optional()
+});
+export {
+  spPageGetBySlugsInput
+};