+4

.oxfmtrc.json

reviewed

··· 1 1 + { 2 2 + "$schema": "./node_modules/oxfmt/configuration_schema.json", 3 3 + "ignorePatterns": ["api/src/db/drizzle/**"] 4 4 + }

+2 -2

api/drizzle.config.ts

reviewed

··· 3 3 4 4 try { 5 5 process.loadEnvFile(".env"); 6 6 - } catch { } 6 6 + } catch {} 7 7 8 8 - console.log(process.env.DATABASE_URL) 8 8 + console.log(process.env.DATABASE_URL); 9 9 10 10 export default defineConfig({ 11 11 casing: "snake_case",

+2 -6

api/lexicons/sh/tangled/feed/reaction.json

reviewed

··· 9 9 "key": "tid", 10 10 "record": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "subject", 14 14 - "reaction", 15 15 - "createdAt" 16 16 - ], 12 12 + "required": ["subject", "reaction", "createdAt"], 17 13 "properties": { 18 14 "subject": { 19 15 "type": "string", ··· 21 17 }, 22 18 "reaction": { 23 19 "type": "string", 24 24 - "enum": [ "👍", "👎", "😆", "🎉", "🫤", "❤️", "🚀", "👀" ] 20 20 + "enum": ["👍", "👎", "😆", "🎉", "🫤", "❤️", "🚀", "👀"] 25 21 }, 26 22 "createdAt": { 27 23 "type": "string",

+1 -3

api/lexicons/sh/tangled/feed/star.json

reviewed

··· 9 9 "key": "tid", 10 10 "record": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "createdAt" 14 14 - ], 12 12 + "required": ["createdAt"], 15 13 "properties": { 16 14 "subject": { 17 15 "type": "string",

+1 -8

api/lexicons/sh/tangled/git/refUpdate.json

reviewed

··· 8 8 "key": "tid", 9 9 "record": { 10 10 "type": "object", 11 11 - "required": [ 12 12 - "ref", 13 13 - "committerDid", 14 14 - "repoName", 15 15 - "oldSha", 16 16 - "newSha", 17 17 - "meta" 18 18 - ], 11 11 + "required": ["ref", "committerDid", "repoName", "oldSha", "newSha", "meta"], 19 12 "properties": { 20 13 "ref": { 21 14 "type": "string",

+1 -4

api/lexicons/sh/tangled/git/temp/getTag.json

reviewed

··· 6 6 "type": "query", 7 7 "parameters": { 8 8 "type": "params", 9 9 - "required": [ 10 10 - "repo", 11 11 - "tag" 12 12 - ], 9 9 + "required": ["repo", "tag"], 13 10 "properties": { 14 11 "repo": { 15 12 "type": "string",

+6 -27

api/lexicons/sh/tangled/git/temp/getTree.json

reviewed

··· 6 6 "type": "query", 7 7 "parameters": { 8 8 "type": "params", 9 9 - "required": [ 10 10 - "repo", 11 11 - "ref" 12 12 - ], 9 9 + "required": ["repo", "ref"], 13 10 "properties": { 14 11 "repo": { 15 12 "type": "string", ··· 31 28 "encoding": "application/json", 32 29 "schema": { 33 30 "type": "object", 34 34 - "required": [ 35 35 - "ref", 36 36 - "files" 37 37 - ], 31 31 + "required": ["ref", "files"], 38 32 "properties": { 39 33 "ref": { 40 34 "type": "string", ··· 88 82 }, 89 83 "readme": { 90 84 "type": "object", 91 91 - "required": [ 92 92 - "filename", 93 93 - "contents" 94 94 - ], 85 85 + "required": ["filename", "contents"], 95 86 "properties": { 96 87 "filename": { 97 88 "type": "string", ··· 105 96 }, 106 97 "treeEntry": { 107 98 "type": "object", 108 108 - "required": [ 109 109 - "name", 110 110 - "mode", 111 111 - "size" 112 112 - ], 99 99 + "required": ["name", "mode", "size"], 113 100 "properties": { 114 101 "name": { 115 102 "type": "string", ··· 131 118 }, 132 119 "lastCommit": { 133 120 "type": "object", 134 134 - "required": [ 135 135 - "hash", 136 136 - "message", 137 137 - "when" 138 138 - ], 121 121 + "required": ["hash", "message", "when"], 139 122 "properties": { 140 123 "hash": { 141 124 "type": "string", ··· 158 141 }, 159 142 "signature": { 160 143 "type": "object", 161 161 - "required": [ 162 162 - "name", 163 163 - "email", 164 164 - "when" 165 165 - ], 144 144 + "required": ["name", "email", "when"], 166 145 "properties": { 167 146 "name": { 168 147 "type": "string",

+1 -4

api/lexicons/sh/tangled/graph/follow.json

reviewed

··· 9 9 "key": "tid", 10 10 "record": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "subject", 14 14 - "createdAt" 15 15 - ], 12 12 + "required": ["subject", "createdAt"], 16 13 "properties": { 17 14 "subject": { 18 15 "type": "string",

+1 -5

api/lexicons/sh/tangled/graph/vouch.json

reviewed

··· 9 9 "key": "any", 10 10 "record": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "kind", 14 14 - "createdAt" 15 15 - ], 12 12 + "required": ["kind", "createdAt"], 16 13 "properties": { 17 14 "kind": { 18 15 "type": "string", ··· 35 32 } 36 33 } 37 34 } 38 38 -

+1 -5

api/lexicons/sh/tangled/issue/comment.json

reviewed

··· 9 9 "key": "tid", 10 10 "record": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "issue", 14 14 - "body", 15 15 - "createdAt" 16 16 - ], 12 12 + "required": ["issue", "body", "createdAt"], 17 13 "properties": { 18 14 "issue": { 19 15 "type": "string",

+1 -4

api/lexicons/sh/tangled/issue/state.json

reviewed

··· 9 9 "key": "tid", 10 10 "record": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "issue", 14 14 - "state" 15 15 - ], 12 12 + "required": ["issue", "state"], 16 13 "properties": { 17 14 "issue": { 18 15 "type": "string",

+1 -3

api/lexicons/sh/tangled/knot/knot.json

reviewed

··· 9 9 "key": "any", 10 10 "record": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "createdAt" 14 14 - ], 12 12 + "required": ["createdAt"], 15 13 "properties": { 16 14 "createdAt": { 17 15 "type": "string",

+1 -5

api/lexicons/sh/tangled/knot/member.json

reviewed

··· 9 9 "key": "tid", 10 10 "record": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "subject", 14 14 - "domain", 15 15 - "createdAt" 16 16 - ], 12 12 + "required": ["subject", "domain", "createdAt"], 17 13 "properties": { 18 14 "subject": { 19 15 "type": "string",

+5 -1

api/lexicons/sh/tangled/knot/subscribeRepos.json

reviewed

··· 50 50 "required": ["seq", "repo"], 51 51 "properties": { 52 52 "seq": { "type": "integer", "description": "The stream sequence number of this message." }, 53 53 - "repo": { "type": "string", "format": "at-uri", "description": "Repository AT-URI identifier" } 53 53 + "repo": { 54 54 + "type": "string", 55 55 + "format": "at-uri", 56 56 + "description": "Repository AT-URI identifier" 57 57 + } 54 58 } 55 59 } 56 60 }

+1 -3

api/lexicons/sh/tangled/knot/version.json

reviewed

··· 9 9 "encoding": "application/json", 10 10 "schema": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "version" 14 14 - ], 12 12 + "required": ["version"], 15 13 "properties": { 16 14 "version": { 17 15 "type": "string"

+4 -21

api/lexicons/sh/tangled/label/definition.json

reviewed

··· 9 9 "key": "any", 10 10 "record": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "name", 14 14 - "valueType", 15 15 - "scope", 16 16 - "createdAt" 17 17 - ], 12 12 + "required": ["name", "valueType", "scope", "createdAt"], 18 13 "properties": { 19 14 "name": { 20 15 "type": "string", ··· 52 47 }, 53 48 "valueType": { 54 49 "type": "object", 55 55 - "required": [ 56 56 - "type", 57 57 - "format" 58 58 - ], 50 50 + "required": ["type", "format"], 59 51 "properties": { 60 52 "type": { 61 53 "type": "string", 62 62 - "enum": [ 63 63 - "null", 64 64 - "boolean", 65 65 - "integer", 66 66 - "string" 67 67 - ], 54 54 + "enum": ["null", "boolean", "integer", "string"], 68 55 "description": "The concrete type of this label's value." 69 56 }, 70 57 "format": { 71 58 "type": "string", 72 72 - "enum": [ 73 73 - "any", 74 74 - "did", 75 75 - "nsid" 76 76 - ], 59 59 + "enum": ["any", "did", "nsid"], 77 60 "description": "An optional constraint that can be applied on string concrete types." 78 61 }, 79 62 "enum": {

+2 -10

api/lexicons/sh/tangled/label/op.json

reviewed

··· 9 9 "key": "tid", 10 10 "record": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "subject", 14 14 - "add", 15 15 - "delete", 16 16 - "performedAt" 17 17 - ], 12 12 + "required": ["subject", "add", "delete", "performedAt"], 18 13 "properties": { 19 14 "subject": { 20 15 "type": "string", ··· 44 39 }, 45 40 "operand": { 46 41 "type": "object", 47 47 - "required": [ 48 48 - "key", 49 49 - "value" 50 50 - ], 42 42 + "required": ["key", "value"], 51 43 "properties": { 52 44 "key": { 53 45 "type": "string",

+1 -3

api/lexicons/sh/tangled/owner.json

reviewed

··· 9 9 "encoding": "application/json", 10 10 "schema": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "owner" 14 14 - ], 12 12 + "required": ["owner"], 15 13 "properties": { 16 14 "owner": { 17 15 "type": "string",

+9 -44

api/lexicons/sh/tangled/pipeline/pipeline.json

reviewed

··· 9 9 "key": "tid", 10 10 "record": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "triggerMetadata", 14 14 - "workflows" 15 15 - ], 12 12 + "required": ["triggerMetadata", "workflows"], 16 13 "properties": { 17 14 "triggerMetadata": { 18 15 "type": "ref", ··· 30 27 }, 31 28 "triggerMetadata": { 32 29 "type": "object", 33 33 - "required": [ 34 34 - "kind", 35 35 - "repo" 36 36 - ], 30 30 + "required": ["kind", "repo"], 37 31 "properties": { 38 32 "kind": { 39 33 "type": "string", 40 40 - "enum": [ 41 41 - "push", 42 42 - "pull_request", 43 43 - "manual" 44 44 - ] 34 34 + "enum": ["push", "pull_request", "manual"] 45 35 }, 46 36 "repo": { 47 37 "type": "ref", ··· 63 53 }, 64 54 "triggerRepo": { 65 55 "type": "object", 66 66 - "required": [ 67 67 - "knot", 68 68 - "did", 69 69 - "defaultBranch" 70 70 - ], 56 56 + "required": ["knot", "did", "defaultBranch"], 71 57 "properties": { 72 58 "knot": { 73 59 "type": "string" ··· 91 77 }, 92 78 "pushTriggerData": { 93 79 "type": "object", 94 94 - "required": [ 95 95 - "ref", 96 96 - "newSha", 97 97 - "oldSha" 98 98 - ], 80 80 + "required": ["ref", "newSha", "oldSha"], 99 81 "properties": { 100 82 "ref": { 101 83 "type": "string" ··· 114 96 }, 115 97 "pullRequestTriggerData": { 116 98 "type": "object", 117 117 - "required": [ 118 118 - "sourceBranch", 119 119 - "targetBranch", 120 120 - "sourceSha", 121 121 - "action" 122 122 - ], 99 99 + "required": ["sourceBranch", "targetBranch", "sourceSha", "action"], 123 100 "properties": { 124 101 "sourceBranch": { 125 102 "type": "string" ··· 151 128 }, 152 129 "workflow": { 153 130 "type": "object", 154 154 - "required": [ 155 155 - "name", 156 156 - "engine", 157 157 - "clone", 158 158 - "raw" 159 159 - ], 131 131 + "required": ["name", "engine", "clone", "raw"], 160 132 "properties": { 161 133 "name": { 162 134 "type": "string" ··· 175 147 }, 176 148 "cloneOpts": { 177 149 "type": "object", 178 178 - "required": [ 179 179 - "skip", 180 180 - "depth", 181 181 - "submodules" 182 182 - ], 150 150 + "required": ["skip", "depth", "submodules"], 183 151 "properties": { 184 152 "skip": { 185 153 "type": "boolean" ··· 194 162 }, 195 163 "pair": { 196 164 "type": "object", 197 197 - "required": [ 198 198 - "key", 199 199 - "value" 200 200 - ], 165 165 + "required": ["key", "value"], 201 166 "properties": { 202 167 "key": { 203 168 "type": "string"

+1 -8

api/lexicons/sh/tangled/pipeline/status.json

reviewed

··· 24 24 "status": { 25 25 "type": "string", 26 26 "description": "status of the workflow", 27 27 - "enum": [ 28 28 - "pending", 29 29 - "running", 30 30 - "failed", 31 31 - "timeout", 32 32 - "cancelled", 33 33 - "success" 34 34 - ] 27 27 + "enum": ["pending", "running", "failed", "timeout", "cancelled", "success"] 35 28 }, 36 29 "createdAt": { 37 30 "type": "string",

+1 -5

api/lexicons/sh/tangled/publicKey.json

reviewed

··· 9 9 "key": "tid", 10 10 "record": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "key", 14 14 - "name", 15 15 - "createdAt" 16 16 - ], 12 12 + "required": ["key", "name", "createdAt"], 17 13 "properties": { 18 14 "key": { 19 15 "type": "string",

+1 -5

api/lexicons/sh/tangled/pulls/comment.json

reviewed

··· 9 9 "key": "tid", 10 10 "record": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "pull", 14 14 - "body", 15 15 - "createdAt" 16 16 - ], 12 12 + "required": ["pull", "body", "createdAt"], 17 13 "properties": { 18 14 "pull": { 19 15 "type": "string",

+5 -19

api/lexicons/sh/tangled/pulls/pull.json

reviewed

··· 9 9 "key": "tid", 10 10 "record": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "target", 14 14 - "title", 15 15 - "createdAt", 16 16 - "rounds" 17 17 - ], 12 12 + "required": ["target", "title", "createdAt", "rounds"], 18 13 "properties": { 19 14 "title": { 20 15 "type": "string" ··· 64 59 }, 65 60 "target": { 66 61 "type": "object", 67 67 - "required": [ 68 68 - "branch" 69 69 - ], 62 62 + "required": ["branch"], 70 63 "properties": { 71 64 "repo": { 72 65 "type": "string", ··· 83 76 }, 84 77 "source": { 85 78 "type": "object", 86 86 - "required": [ 87 87 - "branch" 88 88 - ], 79 79 + "required": ["branch"], 89 80 "properties": { 90 81 "branch": { 91 82 "type": "string" ··· 102 93 }, 103 94 "round": { 104 95 "type": "object", 105 105 - "required": [ 106 106 - "patchBlob", 107 107 - "createdAt" 108 108 - ], 96 96 + "required": ["patchBlob", "createdAt"], 109 97 "description": "revisions of this pull request, newer rounds are appended to this array. appviews may reject records do not treat this field as append-only. the blob format is gzipped text-based git-format-patches.", 110 98 "properties": { 111 99 "createdAt": { ··· 114 102 }, 115 103 "patchBlob": { 116 104 "type": "blob", 117 117 - "accept": [ 118 118 - "application/gzip" 119 119 - ] 105 105 + "accept": ["application/gzip"] 120 106 } 121 107 } 122 108 }

+1 -4

api/lexicons/sh/tangled/pulls/state.json

reviewed

··· 9 9 "key": "tid", 10 10 "record": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "pull", 14 14 - "status" 15 15 - ], 12 12 + "required": ["pull", "status"], 16 13 "properties": { 17 14 "pull": { 18 15 "type": "string",

+1 -5

api/lexicons/sh/tangled/repo/addSecret.json

reviewed

··· 9 9 "encoding": "application/json", 10 10 "schema": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "repo", 14 14 - "key", 15 15 - "value" 16 16 - ], 12 12 + "required": ["repo", "key", "value"], 17 13 "properties": { 18 14 "repo": { 19 15 "type": "string",

+2 -9

api/lexicons/sh/tangled/repo/artifact.json

reviewed

··· 9 9 "key": "tid", 10 10 "record": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "name", 14 14 - "tag", 15 15 - "createdAt", 16 16 - "artifact" 17 17 - ], 12 12 + "required": ["name", "tag", "createdAt", "artifact"], 18 13 "properties": { 19 14 "name": { 20 15 "type": "string", ··· 43 38 "artifact": { 44 39 "type": "blob", 45 40 "description": "the artifact", 46 46 - "accept": [ 47 47 - "*/*" 48 48 - ], 41 41 + "accept": ["*/*"], 49 42 "maxSize": 52428800 50 43 } 51 44 }

+6 -27

api/lexicons/sh/tangled/repo/blob.json

reviewed

··· 6 6 "type": "query", 7 7 "parameters": { 8 8 "type": "params", 9 9 - "required": [ 10 10 - "repo", 11 11 - "ref", 12 12 - "path" 13 13 - ], 9 9 + "required": ["repo", "ref", "path"], 14 10 "properties": { 15 11 "repo": { 16 12 "type": "string", ··· 35 31 "encoding": "application/json", 36 32 "schema": { 37 33 "type": "object", 38 38 - "required": [ 39 39 - "ref", 40 40 - "path" 41 41 - ], 34 34 + "required": ["ref", "path"], 42 35 "properties": { 43 36 "ref": { 44 37 "type": "string", ··· 55 48 "encoding": { 56 49 "type": "string", 57 50 "description": "Content encoding", 58 58 - "enum": [ 59 59 - "utf-8", 60 60 - "base64" 61 61 - ] 51 51 + "enum": ["utf-8", "base64"] 62 52 }, 63 53 "size": { 64 54 "type": "integer", ··· 108 98 }, 109 99 "lastCommit": { 110 100 "type": "object", 111 111 - "required": [ 112 112 - "hash", 113 113 - "message", 114 114 - "when" 115 115 - ], 101 101 + "required": ["hash", "message", "when"], 116 102 "properties": { 117 103 "hash": { 118 104 "type": "string", ··· 135 121 }, 136 122 "signature": { 137 123 "type": "object", 138 138 - "required": [ 139 139 - "name", 140 140 - "email", 141 141 - "when" 142 142 - ], 124 124 + "required": ["name", "email", "when"], 143 125 "properties": { 144 126 "name": { 145 127 "type": "string", ··· 158 140 }, 159 141 "submodule": { 160 142 "type": "object", 161 161 - "required": [ 162 162 - "name", 163 163 - "url" 164 164 - ], 143 143 + "required": ["name", "url"], 165 144 "properties": { 166 145 "name": { 167 146 "type": "string",

+1 -5

api/lexicons/sh/tangled/repo/collaborator.json

reviewed

··· 9 9 "key": "tid", 10 10 "record": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "subject", 14 14 - "createdAt" 15 15 - ], 12 12 + "required": ["subject", "createdAt"], 16 13 "properties": { 17 14 "subject": { 18 15 "type": "string", ··· 36 33 } 37 34 } 38 35 } 39 39 -

+1 -4

api/lexicons/sh/tangled/repo/create.json

reviewed

··· 9 9 "encoding": "application/json", 10 10 "schema": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "rkey", 14 14 - "name" 15 15 - ], 12 12 + "required": ["rkey", "name"], 16 13 "properties": { 17 14 "rkey": { 18 15 "type": "string",

+1 -4

api/lexicons/sh/tangled/repo/defaultBranch.json

reviewed

··· 9 9 "encoding": "application/json", 10 10 "schema": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "repo", 14 14 - "defaultBranch" 15 15 - ], 12 12 + "required": ["repo", "defaultBranch"], 16 13 "properties": { 17 14 "repo": { 18 15 "type": "string",

+1 -5

api/lexicons/sh/tangled/repo/deleteBranch.json

reviewed

··· 9 9 "encoding": "application/json", 10 10 "schema": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "repo", 14 14 - "branch" 15 15 - ], 12 12 + "required": ["repo", "branch"], 16 13 "properties": { 17 14 "repo": { 18 15 "type": "string", ··· 27 24 } 28 25 } 29 26 } 30 30 -

+1 -6

api/lexicons/sh/tangled/repo/forkSync.json

reviewed

··· 9 9 "encoding": "application/json", 10 10 "schema": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "did", 14 14 - "source", 15 15 - "name", 16 16 - "branch" 17 17 - ], 12 12 + "required": ["did", "source", "name", "branch"], 18 13 "properties": { 19 14 "did": { 20 15 "type": "string",

+2 -8

api/lexicons/sh/tangled/repo/hiddenRef.json

reviewed

··· 9 9 "encoding": "application/json", 10 10 "schema": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "repo", 14 14 - "forkRef", 15 15 - "remoteRef" 16 16 - ], 12 12 + "required": ["repo", "forkRef", "remoteRef"], 17 13 "properties": { 18 14 "repo": { 19 15 "type": "string", ··· 35 31 "encoding": "application/json", 36 32 "schema": { 37 33 "type": "object", 38 38 - "required": [ 39 39 - "success" 40 40 - ], 34 34 + "required": ["success"], 41 35 "properties": { 42 36 "success": { 43 37 "type": "boolean",

+3 -12

api/lexicons/sh/tangled/repo/listSecrets.json

reviewed

··· 6 6 "type": "query", 7 7 "parameters": { 8 8 "type": "params", 9 9 - "required": [ 10 10 - "repo" 11 11 - ], 9 9 + "required": ["repo"], 12 10 "properties": { 13 11 "repo": { 14 12 "type": "string", ··· 20 18 "encoding": "application/json", 21 19 "schema": { 22 20 "type": "object", 23 23 - "required": [ 24 24 - "secrets" 25 25 - ], 21 21 + "required": ["secrets"], 26 22 "properties": { 27 23 "secrets": { 28 24 "type": "array", ··· 37 33 }, 38 34 "secret": { 39 35 "type": "object", 40 40 - "required": [ 41 41 - "repo", 42 42 - "key", 43 43 - "createdAt", 44 44 - "createdBy" 45 45 - ], 36 36 + "required": ["repo", "key", "createdAt", "createdBy"], 46 37 "properties": { 47 38 "repo": { 48 39 "type": "string",

+1 -4

api/lexicons/sh/tangled/repo/removeSecret.json

reviewed

··· 9 9 "encoding": "application/json", 10 10 "schema": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "repo", 14 14 - "key" 15 15 - ], 12 12 + "required": ["repo", "key"], 16 13 "properties": { 17 14 "repo": { 18 15 "type": "string",

+1 -5

api/lexicons/sh/tangled/repo/repo.json

reviewed

··· 9 9 "key": "tid", 10 10 "record": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "name", 14 14 - "knot", 15 15 - "createdAt" 16 16 - ], 12 12 + "required": ["name", "knot", "createdAt"], 17 13 "properties": { 18 14 "name": { 19 15 "type": "string",

+1 -4

api/lexicons/sh/tangled/repo/tag.json

reviewed

··· 6 6 "type": "query", 7 7 "parameters": { 8 8 "type": "params", 9 9 - "required": [ 10 10 - "repo", 11 11 - "tag" 12 12 - ], 9 9 + "required": ["repo", "tag"], 13 10 "properties": { 14 11 "repo": { 15 12 "type": "string",

+6 -27

api/lexicons/sh/tangled/repo/tree.json

reviewed

··· 6 6 "type": "query", 7 7 "parameters": { 8 8 "type": "params", 9 9 - "required": [ 10 10 - "repo", 11 11 - "ref" 12 12 - ], 9 9 + "required": ["repo", "ref"], 13 10 "properties": { 14 11 "repo": { 15 12 "type": "string", ··· 30 27 "encoding": "application/json", 31 28 "schema": { 32 29 "type": "object", 33 33 - "required": [ 34 34 - "ref", 35 35 - "files" 36 36 - ], 30 30 + "required": ["ref", "files"], 37 31 "properties": { 38 32 "ref": { 39 33 "type": "string", ··· 87 81 }, 88 82 "readme": { 89 83 "type": "object", 90 90 - "required": [ 91 91 - "filename", 92 92 - "contents" 93 93 - ], 84 84 + "required": ["filename", "contents"], 94 85 "properties": { 95 86 "filename": { 96 87 "type": "string", ··· 104 95 }, 105 96 "treeEntry": { 106 97 "type": "object", 107 107 - "required": [ 108 108 - "name", 109 109 - "mode", 110 110 - "size" 111 111 - ], 98 98 + "required": ["name", "mode", "size"], 112 99 "properties": { 113 100 "name": { 114 101 "type": "string", ··· 130 117 }, 131 118 "lastCommit": { 132 119 "type": "object", 133 133 - "required": [ 134 134 - "hash", 135 135 - "message", 136 136 - "when" 137 137 - ], 120 120 + "required": ["hash", "message", "when"], 138 121 "properties": { 139 122 "hash": { 140 123 "type": "string", ··· 157 140 }, 158 141 "signature": { 159 142 "type": "object", 160 160 - "required": [ 161 161 - "name", 162 162 - "email", 163 163 - "when" 164 164 - ], 143 143 + "required": ["name", "email", "when"], 165 144 "properties": { 166 145 "name": { 167 146 "type": "string",

+1 -5

api/lexicons/sh/tangled/spindle/member.json

reviewed

··· 9 9 "key": "tid", 10 10 "record": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "subject", 14 14 - "instance", 15 15 - "createdAt" 16 16 - ], 12 12 + "required": ["subject", "instance", "createdAt"], 17 13 "properties": { 18 14 "subject": { 19 15 "type": "string",

+1 -4

api/lexicons/sh/tangled/spindle/spindle.json

reviewed

··· 9 9 "key": "any", 10 10 "record": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "createdAt" 14 14 - ], 12 12 + "required": ["createdAt"], 15 13 "properties": { 16 14 "createdAt": { 17 15 "type": "string", ··· 22 20 } 23 21 } 24 22 } 25 25 -

+1 -6

api/lexicons/sh/tangled/string/string.json

reviewed

··· 9 9 "key": "tid", 10 10 "record": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "filename", 14 14 - "description", 15 15 - "createdAt", 16 16 - "contents" 17 17 - ], 12 12 + "required": ["filename", "description", "createdAt", "contents"], 18 13 "properties": { 19 14 "filename": { 20 15 "type": "string",

+12 -12

api/package.json

reviewed

··· 1 1 { 2 2 - "private": true, 3 2 "name": "api", 4 3 "version": "1.0.0", 4 4 + "private": true, 5 5 + "keywords": [], 6 6 + "license": "ISC", 7 7 + "author": "", 8 8 + "type": "module", 5 9 "imports": { 6 10 "#/*": "./src/*" 7 11 }, ··· 12 16 "db:studio": "drizzle-kit studio", 13 17 "build:lexicons": "rm -rf ./src/lexicons && lex build --lexicons ./lexicons --import-ext \".ts\" --out ./src/lexicons" 14 18 }, 15 15 - "keywords": [], 16 16 - "author": "", 17 17 - "license": "ISC", 18 18 - "devEngines": { 19 19 - "packageManager": { 20 20 - "name": "pnpm", 21 21 - "version": "^11.0.3", 22 22 - "onFail": "download" 23 23 - } 24 24 - }, 25 25 - "type": "module", 26 19 "dependencies": { 27 20 "@atproto/lex": "^0.0.25", 28 21 "@atproto/lexicon": "^0.6.2", ··· 40 33 "@types/pg": "^8.20.0", 41 34 "drizzle-kit": "^0.31.10", 42 35 "tsx": "^4.21.0" 36 36 + }, 37 37 + "devEngines": { 38 38 + "packageManager": { 39 39 + "name": "pnpm", 40 40 + "version": "^11.0.3", 41 41 + "onFail": "download" 42 42 + } 43 43 } 44 44 }

+24 -19

api/src/db/tables/raw_records.ts

reviewed

··· 2 2 import { uuidv7WithDefault } from "../helpers.ts"; 3 3 import { and, isNotNull, or, sql } from "drizzle-orm"; 4 4 5 5 - export const actionEnum = pgEnum('raw_action', ["create", "update", "delete"]); 5 5 + export const actionEnum = pgEnum("raw_action", ["create", "update", "delete"]); 6 6 7 7 - export const rawRecords = pgTable("raw_records", { 8 8 - id: uuidv7WithDefault().primaryKey(), 9 9 - tap_id: bigint({ mode: "bigint" }).notNull().unique(), 10 10 - received_at: timestamp({ withTimezone: true }) 11 11 - .notNull() 12 12 - .defaultNow(), 13 13 - did: text().notNull(), 14 14 - rev: text().notNull(), 15 15 - collection: text().notNull(), 16 16 - rkey: text().notNull(), 17 17 - action: actionEnum().notNull(), 18 18 - cid: text(), // nullable on deletes 19 19 - record: jsonb(), // nullable on deletes 20 20 - }, (table) => [ 21 21 - check("raw_records_not_null_unless_delete", or(sql`${table.action} = 'delete'`, and(isNotNull(table.cid), isNotNull(table.record)))!), 22 22 - index().on(table.collection), 23 23 - index().on(table.did, table.collection, table.rkey), 24 24 - ]); 7 7 + export const rawRecords = pgTable( 8 8 + "raw_records", 9 9 + { 10 10 + id: uuidv7WithDefault().primaryKey(), 11 11 + tap_id: bigint({ mode: "bigint" }).notNull().unique(), 12 12 + received_at: timestamp({ withTimezone: true }).notNull().defaultNow(), 13 13 + did: text().notNull(), 14 14 + rev: text().notNull(), 15 15 + collection: text().notNull(), 16 16 + rkey: text().notNull(), 17 17 + action: actionEnum().notNull(), 18 18 + cid: text(), // nullable on deletes 19 19 + record: jsonb(), // nullable on deletes 20 20 + }, 21 21 + (table) => [ 22 22 + check( 23 23 + "raw_records_not_null_unless_delete", 24 24 + or(sql`${table.action} = 'delete'`, and(isNotNull(table.cid), isNotNull(table.record)))!, 25 25 + ), 26 26 + index().on(table.collection), 27 27 + index().on(table.did, table.collection, table.rkey), 28 28 + ], 29 29 + );

+770 -641

api/src/db/tables/tangled.ts

reviewed

··· 1 1 import { and, eq, isNotNull, or, sql } from "drizzle-orm"; 2 2 - import { boolean, check, integer, jsonb, pgEnum, pgTable, primaryKey, text, timestamp } from "drizzle-orm/pg-core"; 2 2 + import { 3 3 + boolean, 4 4 + check, 5 5 + integer, 6 6 + jsonb, 7 7 + pgEnum, 8 8 + pgTable, 9 9 + primaryKey, 10 10 + text, 11 11 + timestamp, 12 12 + } from "drizzle-orm/pg-core"; 3 13 4 4 - export const tangledProfile = pgTable("tangled_profile", { 5 5 - did: text().primaryKey(), 6 6 - rev: text().notNull(), 7 7 - // no rkey here, because always self 8 8 - cid: text(), 9 9 - deleted: boolean().notNull(), 14 14 + export const tangledProfile = pgTable( 15 15 + "tangled_profile", 16 16 + { 17 17 + did: text().primaryKey(), 18 18 + rev: text().notNull(), 19 19 + // no rkey here, because always self 20 20 + cid: text(), 21 21 + deleted: boolean().notNull(), 10 22 11 11 - avatar: text(), 12 12 - description: text(), 13 13 - links: text().array(), 14 14 - stats: text().array(), 15 15 - bluesky: boolean(), 16 16 - location: text(), 17 17 - pinnedRepositories: text().array(), 18 18 - pronouns: text(), 19 19 - preferredHandle: text(), 20 20 - }, (table) => [ 21 21 - check("tangled_profile_cid_only_null_if_deleted", or(isNotNull(table.cid), eq(table.deleted, sql`true`))!), 22 22 - check("tangled_profile_non_null_fields", 23 23 - or( 24 24 - eq(table.deleted, sql`true`), 25 25 - and( 26 26 - isNotNull(table.bluesky) 27 27 - ) 28 28 - )! 29 29 - ) 30 30 - ]); 23 23 + avatar: text(), 24 24 + description: text(), 25 25 + links: text().array(), 26 26 + stats: text().array(), 27 27 + bluesky: boolean(), 28 28 + location: text(), 29 29 + pinnedRepositories: text().array(), 30 30 + pronouns: text(), 31 31 + preferredHandle: text(), 32 32 + }, 33 33 + (table) => [ 34 34 + check( 35 35 + "tangled_profile_cid_only_null_if_deleted", 36 36 + or(isNotNull(table.cid), eq(table.deleted, sql`true`))!, 37 37 + ), 38 38 + check( 39 39 + "tangled_profile_non_null_fields", 40 40 + or(eq(table.deleted, sql`true`), and(isNotNull(table.bluesky)))!, 41 41 + ), 42 42 + ], 43 43 + ); 31 44 32 32 - export const tangledReaction = pgTable("tangled_reaction", { 33 33 - did: text().notNull(), 34 34 - rev: text().notNull(), 35 35 - rkey: text().notNull(), 36 36 - cid: text(), 37 37 - deleted: boolean().notNull(), 45 45 + export const tangledReaction = pgTable( 46 46 + "tangled_reaction", 47 47 + { 48 48 + did: text().notNull(), 49 49 + rev: text().notNull(), 50 50 + rkey: text().notNull(), 51 51 + cid: text(), 52 52 + deleted: boolean().notNull(), 38 53 39 39 - subject: text(), 40 40 - reaction: text(), 41 41 - createdAt: timestamp({ withTimezone: true }), 42 42 - }, (table) => [ 43 43 - primaryKey({ columns: [table.did, table.rkey] }), 44 44 - check("tangled_reaction_cid_only_null_if_deleted", or(isNotNull(table.cid), eq(table.deleted, sql`true`))!), 45 45 - check("tangled_reaction_non_null_fields", 46 46 - or( 47 47 - eq(table.deleted, sql`true`), 48 48 - and( 49 49 - isNotNull(table.subject), 50 50 - isNotNull(table.reaction), 51 51 - isNotNull(table.createdAt), 52 52 - ) 53 53 - )! 54 54 - ) 55 55 - ]); 54 54 + subject: text(), 55 55 + reaction: text(), 56 56 + createdAt: timestamp({ withTimezone: true }), 57 57 + }, 58 58 + (table) => [ 59 59 + primaryKey({ columns: [table.did, table.rkey] }), 60 60 + check( 61 61 + "tangled_reaction_cid_only_null_if_deleted", 62 62 + or(isNotNull(table.cid), eq(table.deleted, sql`true`))!, 63 63 + ), 64 64 + check( 65 65 + "tangled_reaction_non_null_fields", 66 66 + or( 67 67 + eq(table.deleted, sql`true`), 68 68 + and(isNotNull(table.subject), isNotNull(table.reaction), isNotNull(table.createdAt)), 69 69 + )!, 70 70 + ), 71 71 + ], 72 72 + ); 56 73 57 57 - export const tangledStar = pgTable("tangled_star", { 58 58 - did: text().notNull(), 59 59 - rev: text().notNull(), 60 60 - rkey: text().notNull(), 61 61 - cid: text(), 62 62 - deleted: boolean().notNull(), 74 74 + export const tangledStar = pgTable( 75 75 + "tangled_star", 76 76 + { 77 77 + did: text().notNull(), 78 78 + rev: text().notNull(), 79 79 + rkey: text().notNull(), 80 80 + cid: text(), 81 81 + deleted: boolean().notNull(), 63 82 64 64 - subject: text(), 65 65 - subjectDid: text(), 66 66 - createdAt: timestamp({ withTimezone: true }), 67 67 - }, (table) => [ 68 68 - primaryKey({ columns: [table.did, table.rkey] }), 69 69 - check("tangled_star_cid_only_null_if_deleted", or(isNotNull(table.cid), eq(table.deleted, sql`true`))!), 70 70 - check("tangled_star_non_null_fields", 71 71 - or( 72 72 - eq(table.deleted, sql`true`), 73 73 - and( 74 74 - isNotNull(table.createdAt), 75 75 - ) 76 76 - )! 77 77 - ) 78 78 - ]); 83 83 + subject: text(), 84 84 + subjectDid: text(), 85 85 + createdAt: timestamp({ withTimezone: true }), 86 86 + }, 87 87 + (table) => [ 88 88 + primaryKey({ columns: [table.did, table.rkey] }), 89 89 + check( 90 90 + "tangled_star_cid_only_null_if_deleted", 91 91 + or(isNotNull(table.cid), eq(table.deleted, sql`true`))!, 92 92 + ), 93 93 + check( 94 94 + "tangled_star_non_null_fields", 95 95 + or(eq(table.deleted, sql`true`), and(isNotNull(table.createdAt)))!, 96 96 + ), 97 97 + ], 98 98 + ); 79 99 80 80 - export const tangledRefUpdate = pgTable("tangled_ref_update", { 81 81 - did: text().notNull(), 82 82 - rev: text().notNull(), 83 83 - rkey: text().notNull(), 84 84 - cid: text(), 85 85 - deleted: boolean().notNull(), 100 100 + export const tangledRefUpdate = pgTable( 101 101 + "tangled_ref_update", 102 102 + { 103 103 + did: text().notNull(), 104 104 + rev: text().notNull(), 105 105 + rkey: text().notNull(), 106 106 + cid: text(), 107 107 + deleted: boolean().notNull(), 86 108 87 87 - ref: text(), 88 88 - committerDid: text(), 89 89 - ownerDid: text(), 90 90 - repoDid: text(), 91 91 - repoName: text(), 92 92 - oldSha: text(), 93 93 - newSha: text(), 94 94 - metaIsDefaultRef: boolean(), 95 95 - metaLangBreakdown: jsonb(), 96 96 - metaCommitCount: jsonb(), 97 97 - }, (table) => [ 98 98 - primaryKey({ columns: [table.did, table.rkey] }), 99 99 - check("tangled_ref_update_cid_only_null_if_deleted", or(isNotNull(table.cid), eq(table.deleted, sql`true`))!), 100 100 - check("tangled_ref_update_non_null_fields", 101 101 - or( 102 102 - eq(table.deleted, sql`true`), 103 103 - and( 104 104 - isNotNull(table.ref), 105 105 - isNotNull(table.committerDid), 106 106 - isNotNull(table.repoName), 107 107 - isNotNull(table.oldSha), 108 108 - isNotNull(table.newSha), 109 109 - isNotNull(table.metaIsDefaultRef), 110 110 - isNotNull(table.metaCommitCount), 111 111 - ) 112 112 - )! 113 113 - ) 114 114 - ]); 109 109 + ref: text(), 110 110 + committerDid: text(), 111 111 + ownerDid: text(), 112 112 + repoDid: text(), 113 113 + repoName: text(), 114 114 + oldSha: text(), 115 115 + newSha: text(), 116 116 + metaIsDefaultRef: boolean(), 117 117 + metaLangBreakdown: jsonb(), 118 118 + metaCommitCount: jsonb(), 119 119 + }, 120 120 + (table) => [ 121 121 + primaryKey({ columns: [table.did, table.rkey] }), 122 122 + check( 123 123 + "tangled_ref_update_cid_only_null_if_deleted", 124 124 + or(isNotNull(table.cid), eq(table.deleted, sql`true`))!, 125 125 + ), 126 126 + check( 127 127 + "tangled_ref_update_non_null_fields", 128 128 + or( 129 129 + eq(table.deleted, sql`true`), 130 130 + and( 131 131 + isNotNull(table.ref), 132 132 + isNotNull(table.committerDid), 133 133 + isNotNull(table.repoName), 134 134 + isNotNull(table.oldSha), 135 135 + isNotNull(table.newSha), 136 136 + isNotNull(table.metaIsDefaultRef), 137 137 + isNotNull(table.metaCommitCount), 138 138 + ), 139 139 + )!, 140 140 + ), 141 141 + ], 142 142 + ); 115 143 116 116 - export const tangledFollow = pgTable("tangled_follow", { 117 117 - did: text().notNull(), 118 118 - rev: text().notNull(), 119 119 - rkey: text().notNull(), 120 120 - cid: text(), 121 121 - deleted: boolean().notNull(), 144 144 + export const tangledFollow = pgTable( 145 145 + "tangled_follow", 146 146 + { 147 147 + did: text().notNull(), 148 148 + rev: text().notNull(), 149 149 + rkey: text().notNull(), 150 150 + cid: text(), 151 151 + deleted: boolean().notNull(), 122 152 123 123 - subject: text(), 124 124 - createdAt: timestamp({ withTimezone: true }), 125 125 - }, (table) => [ 126 126 - primaryKey({ columns: [table.did, table.rkey] }), 127 127 - check("tangled_follow_cid_only_null_if_deleted", or(isNotNull(table.cid), eq(table.deleted, sql`true`))!), 128 128 - check("tangled_follow_non_null_fields", 129 129 - or( 130 130 - eq(table.deleted, sql`true`), 131 131 - and( 132 132 - isNotNull(table.subject), 133 133 - isNotNull(table.createdAt), 134 134 - ) 135 135 - )! 136 136 - ) 137 137 - ]); 153 153 + subject: text(), 154 154 + createdAt: timestamp({ withTimezone: true }), 155 155 + }, 156 156 + (table) => [ 157 157 + primaryKey({ columns: [table.did, table.rkey] }), 158 158 + check( 159 159 + "tangled_follow_cid_only_null_if_deleted", 160 160 + or(isNotNull(table.cid), eq(table.deleted, sql`true`))!, 161 161 + ), 162 162 + check( 163 163 + "tangled_follow_non_null_fields", 164 164 + or(eq(table.deleted, sql`true`), and(isNotNull(table.subject), isNotNull(table.createdAt)))!, 165 165 + ), 166 166 + ], 167 167 + ); 138 168 139 139 - export const tangledVouchKind = pgEnum('tangled_vouch_kind', ["vouch", "denounce"]); 169 169 + export const tangledVouchKind = pgEnum("tangled_vouch_kind", ["vouch", "denounce"]); 140 170 141 141 - export const tangledVouch = pgTable("tangled_vouch", { 142 142 - did: text().notNull(), 143 143 - rev: text().notNull(), 144 144 - rkey: text().notNull(), 145 145 - cid: text(), 146 146 - deleted: boolean().notNull(), 171 171 + export const tangledVouch = pgTable( 172 172 + "tangled_vouch", 173 173 + { 174 174 + did: text().notNull(), 175 175 + rev: text().notNull(), 176 176 + rkey: text().notNull(), 177 177 + cid: text(), 178 178 + deleted: boolean().notNull(), 147 179 148 148 - kind: tangledVouchKind(), 149 149 - reason: text(), 150 150 - createdAt: timestamp({ withTimezone: true }), 151 151 - }, (table) => [ 152 152 - primaryKey({ columns: [table.did, table.rkey] }), 153 153 - check("tangled_vouch_cid_only_null_if_deleted", or(isNotNull(table.cid), eq(table.deleted, sql`true`))!), 154 154 - check("tangled_vouch_non_null_fields", 155 155 - or( 156 156 - eq(table.deleted, sql`true`), 157 157 - and( 158 158 - isNotNull(table.kind), 159 159 - isNotNull(table.createdAt), 160 160 - ) 161 161 - )! 162 162 - ) 163 163 - ]); 180 180 + kind: tangledVouchKind(), 181 181 + reason: text(), 182 182 + createdAt: timestamp({ withTimezone: true }), 183 183 + }, 184 184 + (table) => [ 185 185 + primaryKey({ columns: [table.did, table.rkey] }), 186 186 + check( 187 187 + "tangled_vouch_cid_only_null_if_deleted", 188 188 + or(isNotNull(table.cid), eq(table.deleted, sql`true`))!, 189 189 + ), 190 190 + check( 191 191 + "tangled_vouch_non_null_fields", 192 192 + or(eq(table.deleted, sql`true`), and(isNotNull(table.kind), isNotNull(table.createdAt)))!, 193 193 + ), 194 194 + ], 195 195 + ); 164 196 165 165 - export const tangledIssueComment = pgTable("tangled_issue_comment", { 166 166 - did: text().notNull(), 167 167 - rev: text().notNull(), 168 168 - rkey: text().notNull(), 169 169 - cid: text(), 170 170 - deleted: boolean().notNull(), 197 197 + export const tangledIssueComment = pgTable( 198 198 + "tangled_issue_comment", 199 199 + { 200 200 + did: text().notNull(), 201 201 + rev: text().notNull(), 202 202 + rkey: text().notNull(), 203 203 + cid: text(), 204 204 + deleted: boolean().notNull(), 171 205 172 172 - issue: text(), 173 173 - body: text(), 174 174 - createdAt: timestamp({ withTimezone: true }), 175 175 - replyTo: text(), 176 176 - mentions: text().array(), 177 177 - references: text().array(), 178 178 - }, (table) => [ 179 179 - primaryKey({ columns: [table.did, table.rkey] }), 180 180 - check("tangled_issue_comment_cid_only_null_if_deleted", or(isNotNull(table.cid), eq(table.deleted, sql`true`))!), 181 181 - check("tangled_issue_comment_non_null_fields", 182 182 - or( 183 183 - eq(table.deleted, sql`true`), 184 184 - and( 185 185 - isNotNull(table.issue), 186 186 - isNotNull(table.body), 187 187 - isNotNull(table.createdAt), 188 188 - ) 189 189 - )! 190 190 - ) 191 191 - ]); 206 206 + issue: text(), 207 207 + body: text(), 208 208 + createdAt: timestamp({ withTimezone: true }), 209 209 + replyTo: text(), 210 210 + mentions: text().array(), 211 211 + references: text().array(), 212 212 + }, 213 213 + (table) => [ 214 214 + primaryKey({ columns: [table.did, table.rkey] }), 215 215 + check( 216 216 + "tangled_issue_comment_cid_only_null_if_deleted", 217 217 + or(isNotNull(table.cid), eq(table.deleted, sql`true`))!, 218 218 + ), 219 219 + check( 220 220 + "tangled_issue_comment_non_null_fields", 221 221 + or( 222 222 + eq(table.deleted, sql`true`), 223 223 + and(isNotNull(table.issue), isNotNull(table.body), isNotNull(table.createdAt)), 224 224 + )!, 225 225 + ), 226 226 + ], 227 227 + ); 228 228 + 229 229 + export const tangledIssue = pgTable( 230 230 + "tangled_issue", 231 231 + { 232 232 + did: text().notNull(), 233 233 + rev: text().notNull(), 234 234 + rkey: text().notNull(), 235 235 + cid: text(), 236 236 + deleted: boolean().notNull(), 192 237 193 193 - export const tangledIssue = pgTable("tangled_issue", { 194 194 - did: text().notNull(), 195 195 - rev: text().notNull(), 196 196 - rkey: text().notNull(), 197 197 - cid: text(), 198 198 - deleted: boolean().notNull(), 238 238 + repo: text(), 239 239 + repoDid: text(), 240 240 + title: text(), 241 241 + body: text(), 242 242 + createdAt: timestamp({ withTimezone: true }), 243 243 + mentions: text().array(), 244 244 + references: text().array(), 245 245 + }, 246 246 + (table) => [ 247 247 + primaryKey({ columns: [table.did, table.rkey] }), 248 248 + check( 249 249 + "tangled_issue_cid_only_null_if_deleted", 250 250 + or(isNotNull(table.cid), eq(table.deleted, sql`true`))!, 251 251 + ), 252 252 + check( 253 253 + "tangled_issue_non_null_fields", 254 254 + or(eq(table.deleted, sql`true`), and(isNotNull(table.title), isNotNull(table.createdAt)))!, 255 255 + ), 256 256 + ], 257 257 + ); 199 258 200 200 - repo: text(), 201 201 - repoDid: text(), 202 202 - title: text(), 203 203 - body: text(), 204 204 - createdAt: timestamp({ withTimezone: true }), 205 205 - mentions: text().array(), 206 206 - references: text().array(), 207 207 - }, (table) => [ 208 208 - primaryKey({ columns: [table.did, table.rkey] }), 209 209 - check("tangled_issue_cid_only_null_if_deleted", or(isNotNull(table.cid), eq(table.deleted, sql`true`))!), 210 210 - check("tangled_issue_non_null_fields", 211 211 - or( 212 212 - eq(table.deleted, sql`true`), 213 213 - and( 214 214 - isNotNull(table.title), 215 215 - isNotNull(table.createdAt), 216 216 - ) 217 217 - )! 218 218 - ) 219 219 - ]); 259 259 + export const tangledIssueState = pgTable( 260 260 + "tangled_issue_state", 261 261 + { 262 262 + did: text().notNull(), 263 263 + rev: text().notNull(), 264 264 + rkey: text().notNull(), 265 265 + cid: text(), 266 266 + deleted: boolean().notNull(), 220 267 221 221 - export const tangledIssueState = pgTable("tangled_issue_state", { 222 222 - did: text().notNull(), 223 223 - rev: text().notNull(), 224 224 - rkey: text().notNull(), 225 225 - cid: text(), 226 226 - deleted: boolean().notNull(), 268 268 + issue: text(), 269 269 + state: text(), 270 270 + }, 271 271 + (table) => [ 272 272 + primaryKey({ columns: [table.did, table.rkey] }), 273 273 + check( 274 274 + "tangled_issue_state_cid_only_null_if_deleted", 275 275 + or(isNotNull(table.cid), eq(table.deleted, sql`true`))!, 276 276 + ), 277 277 + check( 278 278 + "tangled_issue_state_non_null_fields", 279 279 + or(eq(table.deleted, sql`true`), and(isNotNull(table.issue), isNotNull(table.state)))!, 280 280 + ), 281 281 + ], 282 282 + ); 227 283 228 228 - issue: text(), 229 229 - state: text(), 230 230 - }, (table) => [ 231 231 - primaryKey({ columns: [table.did, table.rkey] }), 232 232 - check("tangled_issue_state_cid_only_null_if_deleted", or(isNotNull(table.cid), eq(table.deleted, sql`true`))!), 233 233 - check("tangled_issue_state_non_null_fields", 234 234 - or( 235 235 - eq(table.deleted, sql`true`), 236 236 - and( 237 237 - isNotNull(table.issue), 238 238 - isNotNull(table.state), 239 239 - ) 240 240 - )! 241 241 - ) 242 242 - ]); 284 284 + export const tangledKnot = pgTable( 285 285 + "tangled_knot", 286 286 + { 287 287 + did: text().notNull(), 288 288 + rev: text().notNull(), 289 289 + rkey: text().notNull(), 290 290 + cid: text(), 291 291 + deleted: boolean().notNull(), 243 292 244 244 - export const tangledKnot = pgTable("tangled_knot", { 245 245 - did: text().notNull(), 246 246 - rev: text().notNull(), 247 247 - rkey: text().notNull(), 248 248 - cid: text(), 249 249 - deleted: boolean().notNull(), 293 293 + createdAt: timestamp({ withTimezone: true }), 294 294 + }, 295 295 + (table) => [ 296 296 + primaryKey({ columns: [table.did, table.rkey] }), 297 297 + check( 298 298 + "tangled_knot_cid_only_null_if_deleted", 299 299 + or(isNotNull(table.cid), eq(table.deleted, sql`true`))!, 300 300 + ), 301 301 + check( 302 302 + "tangled_knot_non_null_fields", 303 303 + or(eq(table.deleted, sql`true`), and(isNotNull(table.createdAt)))!, 304 304 + ), 305 305 + ], 306 306 + ); 250 307 251 251 - createdAt: timestamp({ withTimezone: true }), 252 252 - }, (table) => [ 253 253 - primaryKey({ columns: [table.did, table.rkey] }), 254 254 - check("tangled_knot_cid_only_null_if_deleted", or(isNotNull(table.cid), eq(table.deleted, sql`true`))!), 255 255 - check("tangled_knot_non_null_fields", 256 256 - or( 257 257 - eq(table.deleted, sql`true`), 258 258 - and( 259 259 - isNotNull(table.createdAt), 260 260 - ) 261 261 - )! 262 262 - ) 263 263 - ]); 308 308 + export const tangledKnotMember = pgTable( 309 309 + "tangled_knot_member", 310 310 + { 311 311 + did: text().notNull(), 312 312 + rev: text().notNull(), 313 313 + rkey: text().notNull(), 314 314 + cid: text(), 315 315 + deleted: boolean().notNull(), 264 316 265 265 - export const tangledKnotMember = pgTable("tangled_knot_member", { 266 266 - did: text().notNull(), 267 267 - rev: text().notNull(), 268 268 - rkey: text().notNull(), 269 269 - cid: text(), 270 270 - deleted: boolean().notNull(), 317 317 + subject: text(), 318 318 + domain: text(), 319 319 + createdAt: timestamp({ withTimezone: true }), 320 320 + }, 321 321 + (table) => [ 322 322 + primaryKey({ columns: [table.did, table.rkey] }), 323 323 + check( 324 324 + "tangled_knot_member_cid_only_null_if_deleted", 325 325 + or(isNotNull(table.cid), eq(table.deleted, sql`true`))!, 326 326 + ), 327 327 + check( 328 328 + "tangled_knot_member_non_null_fields", 329 329 + or( 330 330 + eq(table.deleted, sql`true`), 331 331 + and(isNotNull(table.subject), isNotNull(table.domain), isNotNull(table.createdAt)), 332 332 + )!, 333 333 + ), 334 334 + ], 335 335 + ); 271 336 272 272 - subject: text(), 273 273 - domain: text(), 274 274 - createdAt: timestamp({ withTimezone: true }), 275 275 - }, (table) => [ 276 276 - primaryKey({ columns: [table.did, table.rkey] }), 277 277 - check("tangled_knot_member_cid_only_null_if_deleted", or(isNotNull(table.cid), eq(table.deleted, sql`true`))!), 278 278 - check("tangled_knot_member_non_null_fields", 279 279 - or( 280 280 - eq(table.deleted, sql`true`), 281 281 - and( 282 282 - isNotNull(table.subject), 283 283 - isNotNull(table.domain), 284 284 - isNotNull(table.createdAt), 285 285 - ) 286 286 - )! 287 287 - ) 288 288 - ]); 337 337 + export const tangledLabelDefinition = pgTable( 338 338 + "tangled_label_definition", 339 339 + { 340 340 + did: text().notNull(), 341 341 + rev: text().notNull(), 342 342 + rkey: text().notNull(), 343 343 + cid: text(), 344 344 + deleted: boolean().notNull(), 289 345 290 290 - export const tangledLabelDefinition = pgTable("tangled_label_definition", { 291 291 - did: text().notNull(), 292 292 - rev: text().notNull(), 293 293 - rkey: text().notNull(), 294 294 - cid: text(), 295 295 - deleted: boolean().notNull(), 346 346 + name: text(), 347 347 + valueType: text(), 348 348 + valueFormat: text(), 349 349 + valueEnum: text().array(), 350 350 + scope: text().array(), 351 351 + color: text(), 352 352 + createdAt: timestamp({ withTimezone: true }), 353 353 + multiple: boolean(), 354 354 + }, 355 355 + (table) => [ 356 356 + primaryKey({ columns: [table.did, table.rkey] }), 357 357 + check( 358 358 + "tangled_label_definition_cid_only_null_if_deleted", 359 359 + or(isNotNull(table.cid), eq(table.deleted, sql`true`))!, 360 360 + ), 361 361 + check( 362 362 + "tangled_label_definition_non_null_fields", 363 363 + or( 364 364 + eq(table.deleted, sql`true`), 365 365 + and( 366 366 + isNotNull(table.name), 367 367 + isNotNull(table.valueType), 368 368 + isNotNull(table.valueFormat), 369 369 + isNotNull(table.scope), 370 370 + isNotNull(table.createdAt), 371 371 + ), 372 372 + )!, 373 373 + ), 374 374 + ], 375 375 + ); 296 376 297 297 - name: text(), 298 298 - valueType: text(), 299 299 - valueFormat: text(), 300 300 - valueEnum: text().array(), 301 301 - scope: text().array(), 302 302 - color: text(), 303 303 - createdAt: timestamp({ withTimezone: true }), 304 304 - multiple: boolean(), 305 305 - }, (table) => [ 306 306 - primaryKey({ columns: [table.did, table.rkey] }), 307 307 - check("tangled_label_definition_cid_only_null_if_deleted", or(isNotNull(table.cid), eq(table.deleted, sql`true`))!), 308 308 - check("tangled_label_definition_non_null_fields", 309 309 - or( 310 310 - eq(table.deleted, sql`true`), 311 311 - and( 312 312 - isNotNull(table.name), 313 313 - isNotNull(table.valueType), 314 314 - isNotNull(table.valueFormat), 315 315 - isNotNull(table.scope), 316 316 - isNotNull(table.createdAt), 317 317 - ) 318 318 - )! 319 319 - ) 320 320 - ]); 377 377 + export const tangledLabelOp = pgTable( 378 378 + "tangled_label_op", 379 379 + { 380 380 + did: text().notNull(), 381 381 + rev: text().notNull(), 382 382 + rkey: text().notNull(), 383 383 + cid: text(), 384 384 + deleted: boolean().notNull(), 321 385 322 322 - export const tangledLabelOp = pgTable("tangled_label_op", { 323 323 - did: text().notNull(), 324 324 - rev: text().notNull(), 325 325 - rkey: text().notNull(), 326 326 - cid: text(), 327 327 - deleted: boolean().notNull(), 386 386 + subject: text(), 387 387 + performedAt: timestamp({ withTimezone: true }), 388 388 + add: jsonb(), 389 389 + delete: jsonb(), 390 390 + }, 391 391 + (table) => [ 392 392 + primaryKey({ columns: [table.did, table.rkey] }), 393 393 + check( 394 394 + "tangled_label_op_cid_only_null_if_deleted", 395 395 + or(isNotNull(table.cid), eq(table.deleted, sql`true`))!, 396 396 + ), 397 397 + check( 398 398 + "tangled_label_op_non_null_fields", 399 399 + or( 400 400 + eq(table.deleted, sql`true`), 401 401 + and( 402 402 + isNotNull(table.subject), 403 403 + isNotNull(table.add), 404 404 + isNotNull(table.delete), 405 405 + isNotNull(table.performedAt), 406 406 + ), 407 407 + )!, 408 408 + ), 409 409 + ], 410 410 + ); 328 411 329 329 - subject: text(), 330 330 - performedAt: timestamp({ withTimezone: true }), 331 331 - add: jsonb(), 332 332 - delete: jsonb(), 333 333 - }, (table) => [ 334 334 - primaryKey({ columns: [table.did, table.rkey] }), 335 335 - check("tangled_label_op_cid_only_null_if_deleted", or(isNotNull(table.cid), eq(table.deleted, sql`true`))!), 336 336 - check("tangled_label_op_non_null_fields", 337 337 - or( 338 338 - eq(table.deleted, sql`true`), 339 339 - and( 340 340 - isNotNull(table.subject), 341 341 - isNotNull(table.add), 342 342 - isNotNull(table.delete), 343 343 - isNotNull(table.performedAt), 344 344 - ) 345 345 - )! 346 346 - ) 412 412 + export const tangledPipelineTriggerMetadataKind = pgEnum("tangled_pipeline_trigger_metadata_kind", [ 413 413 + "push", 414 414 + "pull_request", 415 415 + "manual", 347 416 ]); 348 417 349 349 - export const tangledPipelineTriggerMetadataKind = pgEnum('tangled_pipeline_trigger_metadata_kind', ["push", "pull_request", "manual"]); 418 418 + export const tangledPipeline = pgTable( 419 419 + "tangled_pipeline", 420 420 + { 421 421 + did: text().notNull(), 422 422 + rev: text().notNull(), 423 423 + rkey: text().notNull(), 424 424 + cid: text(), 425 425 + deleted: boolean().notNull(), 350 426 351 351 - export const tangledPipeline = pgTable("tangled_pipeline", { 352 352 - did: text().notNull(), 353 353 - rev: text().notNull(), 354 354 - rkey: text().notNull(), 355 355 - cid: text(), 356 356 - deleted: boolean().notNull(), 427 427 + triggerMetadataKind: tangledPipelineTriggerMetadataKind(), 428 428 + triggerMetadataRepoKnot: text(), 429 429 + triggerMetadataRepoDid: text(), 430 430 + triggerMetadataRepoRepoDid: text(), // I know, confusing 431 431 + triggerMetadataRepoRepo: text(), // i know, I know, 432 432 + triggerMetadataRepoDefaultBranch: text(), 433 433 + triggerMetadataPushRef: text(), 434 434 + triggerMetadataPushNewSha: text(), 435 435 + triggerMetadataPushOldSha: text(), 436 436 + triggerMetadataPullSourceBranch: text(), 437 437 + triggerMetadataPullTargetBranch: text(), 438 438 + triggerMetadataPullSourceSha: text(), 439 439 + triggerMetadataPullAction: text(), 440 440 + triggerMetadataManual: jsonb(), 357 441 358 358 - triggerMetadataKind: tangledPipelineTriggerMetadataKind(), 359 359 - triggerMetadataRepoKnot: text(), 360 360 - triggerMetadataRepoDid: text(), 361 361 - triggerMetadataRepoRepoDid: text(), // I know, confusing 362 362 - triggerMetadataRepoRepo: text(), // i know, I know, 363 363 - triggerMetadataRepoDefaultBranch: text(), 364 364 - triggerMetadataPushRef: text(), 365 365 - triggerMetadataPushNewSha: text(), 366 366 - triggerMetadataPushOldSha: text(), 367 367 - triggerMetadataPullSourceBranch: text(), 368 368 - triggerMetadataPullTargetBranch: text(), 369 369 - triggerMetadataPullSourceSha: text(), 370 370 - triggerMetadataPullAction: text(), 371 371 - triggerMetadataManual: jsonb(), 372 372 - 373 373 - workflows: jsonb(), 374 374 - }, (table) => [ 375 375 - primaryKey({ columns: [table.did, table.rkey] }), 376 376 - check("tangled_pipeline_cid_only_null_if_deleted", or(isNotNull(table.cid), eq(table.deleted, sql`true`))!), 377 377 - check("tangled_pipeline_non_null_fields", 378 378 - or( 379 379 - eq(table.deleted, sql`true`), 380 380 - and( 381 381 - isNotNull(table.triggerMetadataKind), 382 382 - isNotNull(table.triggerMetadataRepoKnot), 383 383 - isNotNull(table.triggerMetadataRepoDid), 384 384 - isNotNull(table.triggerMetadataRepoDefaultBranch), 385 385 - isNotNull(table.workflows), 386 386 - ) 387 387 - )! 388 388 - ) 389 389 - ]); 442 442 + workflows: jsonb(), 443 443 + }, 444 444 + (table) => [ 445 445 + primaryKey({ columns: [table.did, table.rkey] }), 446 446 + check( 447 447 + "tangled_pipeline_cid_only_null_if_deleted", 448 448 + or(isNotNull(table.cid), eq(table.deleted, sql`true`))!, 449 449 + ), 450 450 + check( 451 451 + "tangled_pipeline_non_null_fields", 452 452 + or( 453 453 + eq(table.deleted, sql`true`), 454 454 + and( 455 455 + isNotNull(table.triggerMetadataKind), 456 456 + isNotNull(table.triggerMetadataRepoKnot), 457 457 + isNotNull(table.triggerMetadataRepoDid), 458 458 + isNotNull(table.triggerMetadataRepoDefaultBranch), 459 459 + isNotNull(table.workflows), 460 460 + ), 461 461 + )!, 462 462 + ), 463 463 + ], 464 464 + ); 390 465 391 391 - export const tangledPipelineStatusStatus = pgEnum('tangled_pipeline_status_status', [ 466 466 + export const tangledPipelineStatusStatus = pgEnum("tangled_pipeline_status_status", [ 392 467 "pending", 393 468 "running", 394 469 "failed", 395 470 "timeout", 396 471 "cancelled", 397 397 - "success" 472 472 + "success", 398 473 ]); 399 474 400 400 - export const tangledPipelineStatus = pgTable("tangled_pipeline_status", { 401 401 - did: text().notNull(), 402 402 - rev: text().notNull(), 403 403 - rkey: text().notNull(), 404 404 - cid: text(), 405 405 - deleted: boolean().notNull(), 475 475 + export const tangledPipelineStatus = pgTable( 476 476 + "tangled_pipeline_status", 477 477 + { 478 478 + did: text().notNull(), 479 479 + rev: text().notNull(), 480 480 + rkey: text().notNull(), 481 481 + cid: text(), 482 482 + deleted: boolean().notNull(), 406 483 407 407 - pipeline: text(), 408 408 - workflow: text(), 409 409 - status: tangledPipelineStatusStatus(), 410 410 - createdAt: timestamp({ withTimezone: true }), 411 411 - error: text(), 412 412 - exitCode: integer(), 413 413 - }, (table) => [ 414 414 - primaryKey({ columns: [table.did, table.rkey] }), 415 415 - check("tangled_pipeline_status_cid_only_null_if_deleted", or(isNotNull(table.cid), eq(table.deleted, sql`true`))!), 416 416 - check("tangled_pipeline_status_non_null_fields", 417 417 - or( 418 418 - eq(table.deleted, sql`true`), 419 419 - and( 420 420 - isNotNull(table.pipeline), 421 421 - isNotNull(table.workflow), 422 422 - isNotNull(table.status), 423 423 - isNotNull(table.createdAt), 424 424 - ) 425 425 - )! 426 426 - ) 427 427 - ]); 484 484 + pipeline: text(), 485 485 + workflow: text(), 486 486 + status: tangledPipelineStatusStatus(), 487 487 + createdAt: timestamp({ withTimezone: true }), 488 488 + error: text(), 489 489 + exitCode: integer(), 490 490 + }, 491 491 + (table) => [ 492 492 + primaryKey({ columns: [table.did, table.rkey] }), 493 493 + check( 494 494 + "tangled_pipeline_status_cid_only_null_if_deleted", 495 495 + or(isNotNull(table.cid), eq(table.deleted, sql`true`))!, 496 496 + ), 497 497 + check( 498 498 + "tangled_pipeline_status_non_null_fields", 499 499 + or( 500 500 + eq(table.deleted, sql`true`), 501 501 + and( 502 502 + isNotNull(table.pipeline), 503 503 + isNotNull(table.workflow), 504 504 + isNotNull(table.status), 505 505 + isNotNull(table.createdAt), 506 506 + ), 507 507 + )!, 508 508 + ), 509 509 + ], 510 510 + ); 428 511 429 429 - export const tangledPublicKey = pgTable("tangled_public_key", { 430 430 - did: text().notNull(), 431 431 - rev: text().notNull(), 432 432 - rkey: text().notNull(), 433 433 - cid: text(), 434 434 - deleted: boolean().notNull(), 512 512 + export const tangledPublicKey = pgTable( 513 513 + "tangled_public_key", 514 514 + { 515 515 + did: text().notNull(), 516 516 + rev: text().notNull(), 517 517 + rkey: text().notNull(), 518 518 + cid: text(), 519 519 + deleted: boolean().notNull(), 435 520 436 436 - key: text(), 437 437 - name: text(), 438 438 - createdAt: timestamp({ withTimezone: true }), 439 439 - }, (table) => [ 440 440 - primaryKey({ columns: [table.did, table.rkey] }), 441 441 - check("tangled_public_key_cid_only_null_if_deleted", or(isNotNull(table.cid), eq(table.deleted, sql`true`))!), 442 442 - check("tangled_public_key_non_null_fields", 443 443 - or( 444 444 - eq(table.deleted, sql`true`), 445 445 - and( 446 446 - isNotNull(table.key), 447 447 - isNotNull(table.name), 448 448 - isNotNull(table.createdAt), 449 449 - ) 450 450 - )! 451 451 - ) 452 452 - ]); 521 521 + key: text(), 522 522 + name: text(), 523 523 + createdAt: timestamp({ withTimezone: true }), 524 524 + }, 525 525 + (table) => [ 526 526 + primaryKey({ columns: [table.did, table.rkey] }), 527 527 + check( 528 528 + "tangled_public_key_cid_only_null_if_deleted", 529 529 + or(isNotNull(table.cid), eq(table.deleted, sql`true`))!, 530 530 + ), 531 531 + check( 532 532 + "tangled_public_key_non_null_fields", 533 533 + or( 534 534 + eq(table.deleted, sql`true`), 535 535 + and(isNotNull(table.key), isNotNull(table.name), isNotNull(table.createdAt)), 536 536 + )!, 537 537 + ), 538 538 + ], 539 539 + ); 453 540 454 454 - export const tangledPullComment = pgTable("tangled_pull_comment", { 455 455 - did: text().notNull(), 456 456 - rev: text().notNull(), 457 457 - rkey: text().notNull(), 458 458 - cid: text(), 459 459 - deleted: boolean().notNull(), 541 541 + export const tangledPullComment = pgTable( 542 542 + "tangled_pull_comment", 543 543 + { 544 544 + did: text().notNull(), 545 545 + rev: text().notNull(), 546 546 + rkey: text().notNull(), 547 547 + cid: text(), 548 548 + deleted: boolean().notNull(), 460 549 461 461 - pull: text(), 462 462 - body: text(), 463 463 - createdAt: timestamp({ withTimezone: true }), 464 464 - mentions: text().array(), 465 465 - references: text().array(), 466 466 - }, (table) => [ 467 467 - primaryKey({ columns: [table.did, table.rkey] }), 468 468 - check("tangled_pull_comment_cid_only_null_if_deleted", or(isNotNull(table.cid), eq(table.deleted, sql`true`))!), 469 469 - check("tangled_pull_comment_non_null_fields", 470 470 - or( 471 471 - eq(table.deleted, sql`true`), 472 472 - and( 473 473 - isNotNull(table.pull), 474 474 - isNotNull(table.body), 475 475 - isNotNull(table.createdAt), 476 476 - ) 477 477 - )! 478 478 - ) 479 479 - ]); 550 550 + pull: text(), 551 551 + body: text(), 552 552 + createdAt: timestamp({ withTimezone: true }), 553 553 + mentions: text().array(), 554 554 + references: text().array(), 555 555 + }, 556 556 + (table) => [ 557 557 + primaryKey({ columns: [table.did, table.rkey] }), 558 558 + check( 559 559 + "tangled_pull_comment_cid_only_null_if_deleted", 560 560 + or(isNotNull(table.cid), eq(table.deleted, sql`true`))!, 561 561 + ), 562 562 + check( 563 563 + "tangled_pull_comment_non_null_fields", 564 564 + or( 565 565 + eq(table.deleted, sql`true`), 566 566 + and(isNotNull(table.pull), isNotNull(table.body), isNotNull(table.createdAt)), 567 567 + )!, 568 568 + ), 569 569 + ], 570 570 + ); 480 571 481 481 - export const tangledPull = pgTable("tangled_pull", { 482 482 - did: text().notNull(), 483 483 - rev: text().notNull(), 484 484 - rkey: text().notNull(), 485 485 - cid: text(), 486 486 - deleted: boolean().notNull(), 572 572 + export const tangledPull = pgTable( 573 573 + "tangled_pull", 574 574 + { 575 575 + did: text().notNull(), 576 576 + rev: text().notNull(), 577 577 + rkey: text().notNull(), 578 578 + cid: text(), 579 579 + deleted: boolean().notNull(), 487 580 488 488 - title: text(), 489 489 - body: text(), 490 490 - rounds: jsonb(), 491 491 - sourceBranch: text(), 492 492 - sourceRepo: text(), 493 493 - sourceRepoDid: text(), 494 494 - targetBranch: text(), 495 495 - targetRepo: text(), 496 496 - targetRepoDid: text(), 497 497 - createdAt: timestamp({ withTimezone: true }), 498 498 - mentions: text().array(), 499 499 - references: text().array(), 500 500 - dependentOn: text(), 581 581 + title: text(), 582 582 + body: text(), 583 583 + rounds: jsonb(), 584 584 + sourceBranch: text(), 585 585 + sourceRepo: text(), 586 586 + sourceRepoDid: text(), 587 587 + targetBranch: text(), 588 588 + targetRepo: text(), 589 589 + targetRepoDid: text(), 590 590 + createdAt: timestamp({ withTimezone: true }), 591 591 + mentions: text().array(), 592 592 + references: text().array(), 593 593 + dependentOn: text(), 594 594 + }, 595 595 + (table) => [ 596 596 + primaryKey({ columns: [table.did, table.rkey] }), 597 597 + check( 598 598 + "tangled_pull_cid_only_null_if_deleted", 599 599 + or(isNotNull(table.cid), eq(table.deleted, sql`true`))!, 600 600 + ), 601 601 + check( 602 602 + "tangled_pull_non_null_fields", 603 603 + or( 604 604 + eq(table.deleted, sql`true`), 605 605 + and( 606 606 + isNotNull(table.targetBranch), 607 607 + isNotNull(table.title), 608 608 + isNotNull(table.createdAt), 609 609 + isNotNull(table.rounds), 610 610 + ), 611 611 + )!, 612 612 + ), 613 613 + ], 614 614 + ); 501 615 502 502 - }, (table) => [ 503 503 - primaryKey({ columns: [table.did, table.rkey] }), 504 504 - check("tangled_pull_cid_only_null_if_deleted", or(isNotNull(table.cid), eq(table.deleted, sql`true`))!), 505 505 - check("tangled_pull_non_null_fields", 506 506 - or( 507 507 - eq(table.deleted, sql`true`), 508 508 - and( 509 509 - isNotNull(table.targetBranch), 510 510 - isNotNull(table.title), 511 511 - isNotNull(table.createdAt), 512 512 - isNotNull(table.rounds), 513 513 - ) 514 514 - )! 515 515 - ) 516 516 - ]); 616 616 + export const tangledPullStatus = pgTable( 617 617 + "tangled_pull_status", 618 618 + { 619 619 + did: text().notNull(), 620 620 + rev: text().notNull(), 621 621 + rkey: text().notNull(), 622 622 + cid: text(), 623 623 + deleted: boolean().notNull(), 517 624 518 518 - export const tangledPullStatus = pgTable("tangled_pull_status", { 519 519 - did: text().notNull(), 520 520 - rev: text().notNull(), 521 521 - rkey: text().notNull(), 522 522 - cid: text(), 523 523 - deleted: boolean().notNull(), 625 625 + pull: text(), 626 626 + status: text(), 627 627 + }, 628 628 + (table) => [ 629 629 + primaryKey({ columns: [table.did, table.rkey] }), 630 630 + check( 631 631 + "tangled_pull_status_cid_only_null_if_deleted", 632 632 + or(isNotNull(table.cid), eq(table.deleted, sql`true`))!, 633 633 + ), 634 634 + check( 635 635 + "tangled_pull_status_non_null_fields", 636 636 + or(eq(table.deleted, sql`true`), and(isNotNull(table.pull), isNotNull(table.status)))!, 637 637 + ), 638 638 + ], 639 639 + ); 524 640 525 525 - pull: text(), 526 526 - status: text(), 527 527 - }, (table) => [ 528 528 - primaryKey({ columns: [table.did, table.rkey] }), 529 529 - check("tangled_pull_status_cid_only_null_if_deleted", or(isNotNull(table.cid), eq(table.deleted, sql`true`))!), 530 530 - check("tangled_pull_status_non_null_fields", 531 531 - or( 532 532 - eq(table.deleted, sql`true`), 533 533 - and( 534 534 - isNotNull(table.pull), 535 535 - isNotNull(table.status), 536 536 - ) 537 537 - )! 538 538 - ) 539 539 - ]); 540 540 - 541 541 - export const tangledArtifact = pgTable("tangled_artifact", { 542 542 - did: text().notNull(), 543 543 - rev: text().notNull(), 544 544 - rkey: text().notNull(), 545 545 - cid: text(), 546 546 - deleted: boolean().notNull(), 641 641 + export const tangledArtifact = pgTable( 642 642 + "tangled_artifact", 643 643 + { 644 644 + did: text().notNull(), 645 645 + rev: text().notNull(), 646 646 + rkey: text().notNull(), 647 647 + cid: text(), 648 648 + deleted: boolean().notNull(), 547 649 548 548 - name: text(), 549 549 - repo: text(), 550 550 - repoDid: text(), 551 551 - tag: text(), // TODO: look into making this... bytes 552 552 - createdAt: timestamp({ withTimezone: true }), 553 553 - artifactRef: text(), 554 554 - artifactSize: integer(), 555 555 - artifactMimeType: text(), 556 556 - }, (table) => [ 557 557 - primaryKey({ columns: [table.did, table.rkey] }), 558 558 - check("tangled_artifact_cid_only_null_if_deleted", or(isNotNull(table.cid), eq(table.deleted, sql`true`))!), 559 559 - check("tangled_artifact_non_null_fields", 560 560 - or( 561 561 - eq(table.deleted, sql`true`), 562 562 - and( 563 563 - isNotNull(table.name), 564 564 - isNotNull(table.tag), 565 565 - isNotNull(table.createdAt), 566 566 - isNotNull(table.artifactRef), 567 567 - isNotNull(table.artifactSize), 568 568 - isNotNull(table.artifactMimeType), 569 569 - ) 570 570 - )! 571 571 - ) 572 572 - ]); 650 650 + name: text(), 651 651 + repo: text(), 652 652 + repoDid: text(), 653 653 + tag: text(), // TODO: look into making this... bytes 654 654 + createdAt: timestamp({ withTimezone: true }), 655 655 + artifactRef: text(), 656 656 + artifactSize: integer(), 657 657 + artifactMimeType: text(), 658 658 + }, 659 659 + (table) => [ 660 660 + primaryKey({ columns: [table.did, table.rkey] }), 661 661 + check( 662 662 + "tangled_artifact_cid_only_null_if_deleted", 663 663 + or(isNotNull(table.cid), eq(table.deleted, sql`true`))!, 664 664 + ), 665 665 + check( 666 666 + "tangled_artifact_non_null_fields", 667 667 + or( 668 668 + eq(table.deleted, sql`true`), 669 669 + and( 670 670 + isNotNull(table.name), 671 671 + isNotNull(table.tag), 672 672 + isNotNull(table.createdAt), 673 673 + isNotNull(table.artifactRef), 674 674 + isNotNull(table.artifactSize), 675 675 + isNotNull(table.artifactMimeType), 676 676 + ), 677 677 + )!, 678 678 + ), 679 679 + ], 680 680 + ); 573 681 574 574 - export const tangledCollaborator = pgTable("tangled_collaborator", { 575 575 - did: text().notNull(), 576 576 - rev: text().notNull(), 577 577 - rkey: text().notNull(), 578 578 - cid: text(), 579 579 - deleted: boolean().notNull(), 682 682 + export const tangledCollaborator = pgTable( 683 683 + "tangled_collaborator", 684 684 + { 685 685 + did: text().notNull(), 686 686 + rev: text().notNull(), 687 687 + rkey: text().notNull(), 688 688 + cid: text(), 689 689 + deleted: boolean().notNull(), 580 690 581 581 - subject: text(), 582 582 - repo: text(), 583 583 - repoDid: text(), 584 584 - createdAt: timestamp({ withTimezone: true }), 585 585 - }, (table) => [ 586 586 - primaryKey({ columns: [table.did, table.rkey] }), 587 587 - check("tangled_collaborator_cid_only_null_if_deleted", or(isNotNull(table.cid), eq(table.deleted, sql`true`))!), 588 588 - check("tangled_collaborator_non_null_fields", 589 589 - or( 590 590 - eq(table.deleted, sql`true`), 591 591 - and( 592 592 - isNotNull(table.subject), 593 593 - isNotNull(table.createdAt), 594 594 - ) 595 595 - )! 596 596 - ) 597 597 - ]); 691 691 + subject: text(), 692 692 + repo: text(), 693 693 + repoDid: text(), 694 694 + createdAt: timestamp({ withTimezone: true }), 695 695 + }, 696 696 + (table) => [ 697 697 + primaryKey({ columns: [table.did, table.rkey] }), 698 698 + check( 699 699 + "tangled_collaborator_cid_only_null_if_deleted", 700 700 + or(isNotNull(table.cid), eq(table.deleted, sql`true`))!, 701 701 + ), 702 702 + check( 703 703 + "tangled_collaborator_non_null_fields", 704 704 + or(eq(table.deleted, sql`true`), and(isNotNull(table.subject), isNotNull(table.createdAt)))!, 705 705 + ), 706 706 + ], 707 707 + ); 598 708 599 599 - export const tangledRepo = pgTable("tangled_repo", { 600 600 - did: text().notNull(), 601 601 - rev: text().notNull(), 602 602 - rkey: text().notNull(), 603 603 - cid: text(), 604 604 - deleted: boolean().notNull(), 709 709 + export const tangledRepo = pgTable( 710 710 + "tangled_repo", 711 711 + { 712 712 + did: text().notNull(), 713 713 + rev: text().notNull(), 714 714 + rkey: text().notNull(), 715 715 + cid: text(), 716 716 + deleted: boolean().notNull(), 605 717 606 606 - name: text(), 607 607 - knot: text(), 608 608 - spindle: text(), 609 609 - description: text(), 610 610 - website: text(), 611 611 - topics: text().array(), 612 612 - source: text(), 613 613 - labels: text().array(), 614 614 - repoDid: text(), 615 615 - createdAt: timestamp({ withTimezone: true }), 616 616 - }, (table) => [ 617 617 - primaryKey({ columns: [table.did, table.rkey] }), 618 618 - check("tangled_repo_cid_only_null_if_deleted", or(isNotNull(table.cid), eq(table.deleted, sql`true`))!), 619 619 - check("tangled_repo_non_null_fields", 620 620 - or( 621 621 - eq(table.deleted, sql`true`), 622 622 - and( 623 623 - isNotNull(table.name), 624 624 - isNotNull(table.knot), 625 625 - isNotNull(table.createdAt), 626 626 - ) 627 627 - )! 628 628 - ) 629 629 - ]); 718 718 + name: text(), 719 719 + knot: text(), 720 720 + spindle: text(), 721 721 + description: text(), 722 722 + website: text(), 723 723 + topics: text().array(), 724 724 + source: text(), 725 725 + labels: text().array(), 726 726 + repoDid: text(), 727 727 + createdAt: timestamp({ withTimezone: true }), 728 728 + }, 729 729 + (table) => [ 730 730 + primaryKey({ columns: [table.did, table.rkey] }), 731 731 + check( 732 732 + "tangled_repo_cid_only_null_if_deleted", 733 733 + or(isNotNull(table.cid), eq(table.deleted, sql`true`))!, 734 734 + ), 735 735 + check( 736 736 + "tangled_repo_non_null_fields", 737 737 + or( 738 738 + eq(table.deleted, sql`true`), 739 739 + and(isNotNull(table.name), isNotNull(table.knot), isNotNull(table.createdAt)), 740 740 + )!, 741 741 + ), 742 742 + ], 743 743 + ); 630 744 631 631 - export const tangledSpindleMember = pgTable("tangled_spindle_member", { 632 632 - did: text().notNull(), 633 633 - rev: text().notNull(), 634 634 - rkey: text().notNull(), 635 635 - cid: text(), 636 636 - deleted: boolean().notNull(), 745 745 + export const tangledSpindleMember = pgTable( 746 746 + "tangled_spindle_member", 747 747 + { 748 748 + did: text().notNull(), 749 749 + rev: text().notNull(), 750 750 + rkey: text().notNull(), 751 751 + cid: text(), 752 752 + deleted: boolean().notNull(), 637 753 638 638 - subject: text(), 639 639 - instance: text(), 640 640 - createdAt: timestamp({ withTimezone: true }), 641 641 - }, (table) => [ 642 642 - primaryKey({ columns: [table.did, table.rkey] }), 643 643 - check("tangled_spindle_member_cid_only_null_if_deleted", or(isNotNull(table.cid), eq(table.deleted, sql`true`))!), 644 644 - check("tangled_spindle_member_non_null_fields", 645 645 - or( 646 646 - eq(table.deleted, sql`true`), 647 647 - and( 648 648 - isNotNull(table.subject), 649 649 - isNotNull(table.instance), 650 650 - isNotNull(table.createdAt), 651 651 - ) 652 652 - )! 653 653 - ) 654 654 - ]); 754 754 + subject: text(), 755 755 + instance: text(), 756 756 + createdAt: timestamp({ withTimezone: true }), 757 757 + }, 758 758 + (table) => [ 759 759 + primaryKey({ columns: [table.did, table.rkey] }), 760 760 + check( 761 761 + "tangled_spindle_member_cid_only_null_if_deleted", 762 762 + or(isNotNull(table.cid), eq(table.deleted, sql`true`))!, 763 763 + ), 764 764 + check( 765 765 + "tangled_spindle_member_non_null_fields", 766 766 + or( 767 767 + eq(table.deleted, sql`true`), 768 768 + and(isNotNull(table.subject), isNotNull(table.instance), isNotNull(table.createdAt)), 769 769 + )!, 770 770 + ), 771 771 + ], 772 772 + ); 655 773 656 656 - export const tangledSpindle = pgTable("tangled_spindle", { 657 657 - did: text().notNull(), 658 658 - rev: text().notNull(), 659 659 - rkey: text().notNull(), 660 660 - cid: text(), 661 661 - deleted: boolean().notNull(), 774 774 + export const tangledSpindle = pgTable( 775 775 + "tangled_spindle", 776 776 + { 777 777 + did: text().notNull(), 778 778 + rev: text().notNull(), 779 779 + rkey: text().notNull(), 780 780 + cid: text(), 781 781 + deleted: boolean().notNull(), 662 782 663 663 - createdAt: timestamp({ withTimezone: true }), 664 664 - }, (table) => [ 665 665 - primaryKey({ columns: [table.did, table.rkey] }), 666 666 - check("tangled_spindle_cid_only_null_if_deleted", or(isNotNull(table.cid), eq(table.deleted, sql`true`))!), 667 667 - check("tangled_spindle_non_null_fields", 668 668 - or( 669 669 - eq(table.deleted, sql`true`), 670 670 - and( 671 671 - isNotNull(table.createdAt), 672 672 - ) 673 673 - )! 674 674 - ) 675 675 - ]); 783 783 + createdAt: timestamp({ withTimezone: true }), 784 784 + }, 785 785 + (table) => [ 786 786 + primaryKey({ columns: [table.did, table.rkey] }), 787 787 + check( 788 788 + "tangled_spindle_cid_only_null_if_deleted", 789 789 + or(isNotNull(table.cid), eq(table.deleted, sql`true`))!, 790 790 + ), 791 791 + check( 792 792 + "tangled_spindle_non_null_fields", 793 793 + or(eq(table.deleted, sql`true`), and(isNotNull(table.createdAt)))!, 794 794 + ), 795 795 + ], 796 796 + ); 676 797 677 677 - export const tangledString = pgTable("tangled_string", { 678 678 - did: text().notNull(), 679 679 - rev: text().notNull(), 680 680 - rkey: text().notNull(), 681 681 - cid: text(), 682 682 - deleted: boolean().notNull(), 798 798 + export const tangledString = pgTable( 799 799 + "tangled_string", 800 800 + { 801 801 + did: text().notNull(), 802 802 + rev: text().notNull(), 803 803 + rkey: text().notNull(), 804 804 + cid: text(), 805 805 + deleted: boolean().notNull(), 683 806 684 684 - filename: text(), 685 685 - description: text(), 686 686 - createdAt: timestamp({ withTimezone: true }), 687 687 - contents: text(), 688 688 - }, (table) => [ 689 689 - primaryKey({ columns: [table.did, table.rkey] }), 690 690 - check("tangled_string_cid_only_null_if_deleted", or(isNotNull(table.cid), eq(table.deleted, sql`true`))!), 691 691 - check("tangled_string_non_null_fields", 692 692 - or( 693 693 - eq(table.deleted, sql`true`), 694 694 - and( 695 695 - isNotNull(table.filename), 696 696 - isNotNull(table.description), 697 697 - isNotNull(table.createdAt), 698 698 - isNotNull(table.contents), 699 699 - ) 700 700 - )! 701 701 - ) 702 702 - ]); 807 807 + filename: text(), 808 808 + description: text(), 809 809 + createdAt: timestamp({ withTimezone: true }), 810 810 + contents: text(), 811 811 + }, 812 812 + (table) => [ 813 813 + primaryKey({ columns: [table.did, table.rkey] }), 814 814 + check( 815 815 + "tangled_string_cid_only_null_if_deleted", 816 816 + or(isNotNull(table.cid), eq(table.deleted, sql`true`))!, 817 817 + ), 818 818 + check( 819 819 + "tangled_string_non_null_fields", 820 820 + or( 821 821 + eq(table.deleted, sql`true`), 822 822 + and( 823 823 + isNotNull(table.filename), 824 824 + isNotNull(table.description), 825 825 + isNotNull(table.createdAt), 826 826 + isNotNull(table.contents), 827 827 + ), 828 828 + )!, 829 829 + ), 830 830 + ], 831 831 + );

+15 -15

api/src/index.ts

reviewed

··· 1 1 import "./ingest/tap.ts"; 2 2 3 3 - import { Hono } from 'hono' 4 4 - import { serve } from '@hono/node-server' 5 5 - const app = new Hono() 3 3 + import { Hono } from "hono"; 4 4 + import { serve } from "@hono/node-server"; 5 5 + const app = new Hono(); 6 6 7 7 - app.get('/', (c) => c.text('hono!')) 7 7 + app.get("/", (c) => c.text("hono!")); 8 8 9 9 - const server = serve(app, (d) => console.log("Listening on", d)) 9 9 + const server = serve(app, (d) => console.log("Listening on", d)); 10 10 11 11 // graceful shutdown 12 12 - process.on('SIGINT', () => { 13 13 - server.close() 14 14 - process.exit(0) 15 15 - }) 16 16 - process.on('SIGTERM', () => { 12 12 + process.on("SIGINT", () => { 13 13 + server.close(); 14 14 + process.exit(0); 15 15 + }); 16 16 + process.on("SIGTERM", () => { 17 17 server.close((err) => { 18 18 if (err) { 19 19 - console.error(err) 20 20 - process.exit(1) 19 19 + console.error(err); 20 20 + process.exit(1); 21 21 } 22 22 - process.exit(0) 23 23 - }) 24 24 - }) 22 22 + process.exit(0); 23 23 + }); 24 24 + });

+41 -35

api/src/ingest/artifact.ts

reviewed

··· 9 9 export const ingestArtifact: CollectionHandler = async (artifacts) => { 10 10 for (const artifact of artifacts) { 11 11 if (artifact.action === "delete") { 12 12 - await db.insert(tangledArtifact).values({ 13 13 - did: artifact.did, 14 14 - rev: artifact.rev, 15 15 - rkey: artifact.rkey, 16 16 - cid: null, 17 17 - deleted: true, 18 18 - }).onConflictDoUpdate({ 19 19 - target: [tangledArtifact.did, tangledArtifact.rkey], 20 20 - set: { 12 12 + await db 13 13 + .insert(tangledArtifact) 14 14 + .values({ 15 15 + did: artifact.did, 21 16 rev: artifact.rev, 17 17 + rkey: artifact.rkey, 22 18 cid: null, 23 23 - deleted: true 24 24 - }, 25 25 - setWhere: lt(tangledArtifact.rev, artifact.rev) 26 26 - }); 19 19 + deleted: true, 20 20 + }) 21 21 + .onConflictDoUpdate({ 22 22 + target: [tangledArtifact.did, tangledArtifact.rkey], 23 23 + set: { 24 24 + rev: artifact.rev, 25 25 + cid: null, 26 26 + deleted: true, 27 27 + }, 28 28 + setWhere: lt(tangledArtifact.rev, artifact.rev), 29 29 + }); 27 30 continue; 28 31 } 29 32 ··· 31 34 if (!validatedRecord.success) continue; 32 35 const { value: artifactRecord } = validatedRecord; 33 36 34 34 - await db.insert(tangledArtifact).values({ 35 35 - did: artifact.did, 36 36 - rev: artifact.rev, 37 37 - rkey: artifact.rkey, 38 38 - cid: artifact.cid, 39 39 - deleted: false, 40 40 - 41 41 - name: artifactRecord.name, 42 42 - repo: artifactRecord.repo, 43 43 - repoDid: artifactRecord.repoDid, 44 44 - tag: encodeHex(artifactRecord.tag), 45 45 - createdAt: new Date(artifactRecord.createdAt), 46 46 - artifactRef: getBlobCidString(artifactRecord.artifact), 47 47 - artifactSize: getBlobSize(artifactRecord.artifact), 48 48 - artifactMimeType: getBlobMime(artifactRecord.artifact), 49 49 - }).onConflictDoUpdate({ 50 50 - target: [tangledArtifact.did, tangledArtifact.rkey], 51 51 - set: { 37 37 + await db 38 38 + .insert(tangledArtifact) 39 39 + .values({ 40 40 + did: artifact.did, 52 41 rev: artifact.rev, 42 42 + rkey: artifact.rkey, 53 43 cid: artifact.cid, 54 44 deleted: false, 55 45 ··· 61 51 artifactRef: getBlobCidString(artifactRecord.artifact), 62 52 artifactSize: getBlobSize(artifactRecord.artifact), 63 53 artifactMimeType: getBlobMime(artifactRecord.artifact), 64 64 - }, 65 65 - setWhere: lt(tangledArtifact.rev, artifact.rev) 66 66 - }) 54 54 + }) 55 55 + .onConflictDoUpdate({ 56 56 + target: [tangledArtifact.did, tangledArtifact.rkey], 57 57 + set: { 58 58 + rev: artifact.rev, 59 59 + cid: artifact.cid, 60 60 + deleted: false, 61 61 + 62 62 + name: artifactRecord.name, 63 63 + repo: artifactRecord.repo, 64 64 + repoDid: artifactRecord.repoDid, 65 65 + tag: encodeHex(artifactRecord.tag), 66 66 + createdAt: new Date(artifactRecord.createdAt), 67 67 + artifactRef: getBlobCidString(artifactRecord.artifact), 68 68 + artifactSize: getBlobSize(artifactRecord.artifact), 69 69 + artifactMimeType: getBlobMime(artifactRecord.artifact), 70 70 + }, 71 71 + setWhere: lt(tangledArtifact.rev, artifact.rev), 72 72 + }); 67 73 } 68 68 - } 74 74 + };

+37 -31

api/src/ingest/collaborator.ts

reviewed

··· 7 7 export const ingestCollaborator: CollectionHandler = async (collaborators) => { 8 8 for (const collaborator of collaborators) { 9 9 if (collaborator.action === "delete") { 10 10 - await db.insert(tangledCollaborator).values({ 11 11 - did: collaborator.did, 12 12 - rev: collaborator.rev, 13 13 - rkey: collaborator.rkey, 14 14 - cid: null, 15 15 - deleted: true, 16 16 - }).onConflictDoUpdate({ 17 17 - target: [tangledCollaborator.did, tangledCollaborator.rkey], 18 18 - set: { 10 10 + await db 11 11 + .insert(tangledCollaborator) 12 12 + .values({ 13 13 + did: collaborator.did, 19 14 rev: collaborator.rev, 15 15 + rkey: collaborator.rkey, 20 16 cid: null, 21 21 - deleted: true 22 22 - }, 23 23 - setWhere: lt(tangledCollaborator.rev, collaborator.rev) 24 24 - }); 17 17 + deleted: true, 18 18 + }) 19 19 + .onConflictDoUpdate({ 20 20 + target: [tangledCollaborator.did, tangledCollaborator.rkey], 21 21 + set: { 22 22 + rev: collaborator.rev, 23 23 + cid: null, 24 24 + deleted: true, 25 25 + }, 26 26 + setWhere: lt(tangledCollaborator.rev, collaborator.rev), 27 27 + }); 25 28 continue; 26 29 } 27 30 ··· 29 32 if (!validatedRecord.success) continue; 30 33 const { value: collaboratorRecord } = validatedRecord; 31 34 32 32 - await db.insert(tangledCollaborator).values({ 33 33 - did: collaborator.did, 34 34 - rev: collaborator.rev, 35 35 - rkey: collaborator.rkey, 36 36 - cid: collaborator.cid, 37 37 - deleted: false, 38 38 - 39 39 - subject: collaboratorRecord.subject, 40 40 - repo: collaboratorRecord.repo, 41 41 - repoDid: collaboratorRecord.repoDid, 42 42 - createdAt: new Date(collaboratorRecord.createdAt), 43 43 - }).onConflictDoUpdate({ 44 44 - target: [tangledCollaborator.did, tangledCollaborator.rkey], 45 45 - set: { 35 35 + await db 36 36 + .insert(tangledCollaborator) 37 37 + .values({ 38 38 + did: collaborator.did, 46 39 rev: collaborator.rev, 40 40 + rkey: collaborator.rkey, 47 41 cid: collaborator.cid, 48 42 deleted: false, 49 43 ··· 51 45 repo: collaboratorRecord.repo, 52 46 repoDid: collaboratorRecord.repoDid, 53 47 createdAt: new Date(collaboratorRecord.createdAt), 54 54 - }, 55 55 - setWhere: lt(tangledCollaborator.rev, collaborator.rev) 56 56 - }) 48 48 + }) 49 49 + .onConflictDoUpdate({ 50 50 + target: [tangledCollaborator.did, tangledCollaborator.rkey], 51 51 + set: { 52 52 + rev: collaborator.rev, 53 53 + cid: collaborator.cid, 54 54 + deleted: false, 55 55 + 56 56 + subject: collaboratorRecord.subject, 57 57 + repo: collaboratorRecord.repo, 58 58 + repoDid: collaboratorRecord.repoDid, 59 59 + createdAt: new Date(collaboratorRecord.createdAt), 60 60 + }, 61 61 + setWhere: lt(tangledCollaborator.rev, collaborator.rev), 62 62 + }); 57 63 } 58 58 - } 64 64 + };

+35 -29

api/src/ingest/follow.ts

reviewed

··· 7 7 export const ingestFollow: CollectionHandler = async (follows) => { 8 8 for (const follow of follows) { 9 9 if (follow.action === "delete") { 10 10 - await db.insert(tangledFollow).values({ 11 11 - did: follow.did, 12 12 - rev: follow.rev, 13 13 - rkey: follow.rkey, 14 14 - cid: null, 15 15 - deleted: true, 16 16 - }).onConflictDoUpdate({ 17 17 - target: [tangledFollow.did, tangledFollow.rkey], 18 18 - set: { 10 10 + await db 11 11 + .insert(tangledFollow) 12 12 + .values({ 13 13 + did: follow.did, 19 14 rev: follow.rev, 15 15 + rkey: follow.rkey, 20 16 cid: null, 21 21 - deleted: true 22 22 - }, 23 23 - setWhere: lt(tangledFollow.rev, follow.rev) 24 24 - }); 17 17 + deleted: true, 18 18 + }) 19 19 + .onConflictDoUpdate({ 20 20 + target: [tangledFollow.did, tangledFollow.rkey], 21 21 + set: { 22 22 + rev: follow.rev, 23 23 + cid: null, 24 24 + deleted: true, 25 25 + }, 26 26 + setWhere: lt(tangledFollow.rev, follow.rev), 27 27 + }); 25 28 continue; 26 29 } 27 30 ··· 29 32 if (!validatedRecord.success) continue; 30 33 const { value: followRecord } = validatedRecord; 31 34 32 32 - await db.insert(tangledFollow).values({ 33 33 - did: follow.did, 34 34 - rev: follow.rev, 35 35 - rkey: follow.rkey, 36 36 - cid: follow.cid, 37 37 - deleted: false, 38 38 - 39 39 - subject: followRecord.subject, 40 40 - createdAt: new Date(followRecord.createdAt), 41 41 - }).onConflictDoUpdate({ 42 42 - target: [tangledFollow.did, tangledFollow.rkey], 43 43 - set: { 35 35 + await db 36 36 + .insert(tangledFollow) 37 37 + .values({ 38 38 + did: follow.did, 44 39 rev: follow.rev, 40 40 + rkey: follow.rkey, 45 41 cid: follow.cid, 46 42 deleted: false, 47 43 48 44 subject: followRecord.subject, 49 45 createdAt: new Date(followRecord.createdAt), 50 50 - }, 51 51 - setWhere: lt(tangledFollow.rev, follow.rev) 52 52 - }) 46 46 + }) 47 47 + .onConflictDoUpdate({ 48 48 + target: [tangledFollow.did, tangledFollow.rkey], 49 49 + set: { 50 50 + rev: follow.rev, 51 51 + cid: follow.cid, 52 52 + deleted: false, 53 53 + 54 54 + subject: followRecord.subject, 55 55 + createdAt: new Date(followRecord.createdAt), 56 56 + }, 57 57 + setWhere: lt(tangledFollow.rev, follow.rev), 58 58 + }); 53 59 } 54 54 - } 60 60 + };

+40 -34

api/src/ingest/issue.ts

reviewed

··· 7 7 export const ingestIssue: CollectionHandler = async (issues) => { 8 8 for (const issue of issues) { 9 9 if (issue.action === "delete") { 10 10 - await db.insert(tangledIssue).values({ 11 11 - did: issue.did, 12 12 - rev: issue.rev, 13 13 - rkey: issue.rkey, 14 14 - cid: null, 15 15 - deleted: true, 16 16 - }).onConflictDoUpdate({ 17 17 - target: [tangledIssue.did, tangledIssue.rkey], 18 18 - set: { 10 10 + await db 11 11 + .insert(tangledIssue) 12 12 + .values({ 13 13 + did: issue.did, 19 14 rev: issue.rev, 15 15 + rkey: issue.rkey, 20 16 cid: null, 21 21 - deleted: true 22 22 - }, 23 23 - setWhere: lt(tangledIssue.rev, issue.rev) 24 24 - }); 17 17 + deleted: true, 18 18 + }) 19 19 + .onConflictDoUpdate({ 20 20 + target: [tangledIssue.did, tangledIssue.rkey], 21 21 + set: { 22 22 + rev: issue.rev, 23 23 + cid: null, 24 24 + deleted: true, 25 25 + }, 26 26 + setWhere: lt(tangledIssue.rev, issue.rev), 27 27 + }); 25 28 continue; 26 29 } 27 30 ··· 29 32 if (!validatedRecord.success) continue; 30 33 const { value: issueRecord } = validatedRecord; 31 34 32 32 - await db.insert(tangledIssue).values({ 33 33 - did: issue.did, 34 34 - rev: issue.rev, 35 35 - rkey: issue.rkey, 36 36 - cid: issue.cid, 37 37 - deleted: false, 38 38 - 39 39 - repo: issueRecord.repo, 40 40 - repoDid: issueRecord.repoDid, 41 41 - title: issueRecord.title, 42 42 - body: issueRecord.body, 43 43 - createdAt: new Date(issueRecord.createdAt), 44 44 - mentions: issueRecord.mentions, 45 45 - references: issueRecord.references, 46 46 - }).onConflictDoUpdate({ 47 47 - target: [tangledIssue.did, tangledIssue.rkey], 48 48 - set: { 35 35 + await db 36 36 + .insert(tangledIssue) 37 37 + .values({ 38 38 + did: issue.did, 49 39 rev: issue.rev, 40 40 + rkey: issue.rkey, 50 41 cid: issue.cid, 51 42 deleted: false, 52 43 ··· 57 48 createdAt: new Date(issueRecord.createdAt), 58 49 mentions: issueRecord.mentions, 59 50 references: issueRecord.references, 60 60 - }, 61 61 - setWhere: lt(tangledIssue.rev, issue.rev) 62 62 - }) 51 51 + }) 52 52 + .onConflictDoUpdate({ 53 53 + target: [tangledIssue.did, tangledIssue.rkey], 54 54 + set: { 55 55 + rev: issue.rev, 56 56 + cid: issue.cid, 57 57 + deleted: false, 58 58 + 59 59 + repo: issueRecord.repo, 60 60 + repoDid: issueRecord.repoDid, 61 61 + title: issueRecord.title, 62 62 + body: issueRecord.body, 63 63 + createdAt: new Date(issueRecord.createdAt), 64 64 + mentions: issueRecord.mentions, 65 65 + references: issueRecord.references, 66 66 + }, 67 67 + setWhere: lt(tangledIssue.rev, issue.rev), 68 68 + }); 63 69 } 64 64 - } 70 70 + };

+39 -33

api/src/ingest/issueComment.ts

reviewed

··· 7 7 export const ingestIssueComment: CollectionHandler = async (issueComments) => { 8 8 for (const issueComment of issueComments) { 9 9 if (issueComment.action === "delete") { 10 10 - await db.insert(tangledIssueComment).values({ 11 11 - did: issueComment.did, 12 12 - rev: issueComment.rev, 13 13 - rkey: issueComment.rkey, 14 14 - cid: null, 15 15 - deleted: true, 16 16 - }).onConflictDoUpdate({ 17 17 - target: [tangledIssueComment.did, tangledIssueComment.rkey], 18 18 - set: { 10 10 + await db 11 11 + .insert(tangledIssueComment) 12 12 + .values({ 13 13 + did: issueComment.did, 19 14 rev: issueComment.rev, 15 15 + rkey: issueComment.rkey, 20 16 cid: null, 21 21 - deleted: true 22 22 - }, 23 23 - setWhere: lt(tangledIssueComment.rev, issueComment.rev) 24 24 - }); 17 17 + deleted: true, 18 18 + }) 19 19 + .onConflictDoUpdate({ 20 20 + target: [tangledIssueComment.did, tangledIssueComment.rkey], 21 21 + set: { 22 22 + rev: issueComment.rev, 23 23 + cid: null, 24 24 + deleted: true, 25 25 + }, 26 26 + setWhere: lt(tangledIssueComment.rev, issueComment.rev), 27 27 + }); 25 28 continue; 26 29 } 27 30 ··· 29 32 if (!validatedRecord.success) continue; 30 33 const { value: issueCommentRecord } = validatedRecord; 31 34 32 32 - await db.insert(tangledIssueComment).values({ 33 33 - did: issueComment.did, 34 34 - rev: issueComment.rev, 35 35 - rkey: issueComment.rkey, 36 36 - cid: issueComment.cid, 37 37 - deleted: false, 38 38 - 39 39 - issue: issueCommentRecord.issue, 40 40 - body: issueCommentRecord.body, 41 41 - createdAt: new Date(issueCommentRecord.createdAt), 42 42 - replyTo: issueCommentRecord.replyTo, 43 43 - mentions: issueCommentRecord.mentions, 44 44 - references: issueCommentRecord.references, 45 45 - }).onConflictDoUpdate({ 46 46 - target: [tangledIssueComment.did, tangledIssueComment.rkey], 47 47 - set: { 35 35 + await db 36 36 + .insert(tangledIssueComment) 37 37 + .values({ 38 38 + did: issueComment.did, 48 39 rev: issueComment.rev, 40 40 + rkey: issueComment.rkey, 49 41 cid: issueComment.cid, 50 42 deleted: false, 51 43 ··· 55 47 replyTo: issueCommentRecord.replyTo, 56 48 mentions: issueCommentRecord.mentions, 57 49 references: issueCommentRecord.references, 58 58 - }, 59 59 - setWhere: lt(tangledIssueComment.rev, issueComment.rev) 60 60 - }) 50 50 + }) 51 51 + .onConflictDoUpdate({ 52 52 + target: [tangledIssueComment.did, tangledIssueComment.rkey], 53 53 + set: { 54 54 + rev: issueComment.rev, 55 55 + cid: issueComment.cid, 56 56 + deleted: false, 57 57 + 58 58 + issue: issueCommentRecord.issue, 59 59 + body: issueCommentRecord.body, 60 60 + createdAt: new Date(issueCommentRecord.createdAt), 61 61 + replyTo: issueCommentRecord.replyTo, 62 62 + mentions: issueCommentRecord.mentions, 63 63 + references: issueCommentRecord.references, 64 64 + }, 65 65 + setWhere: lt(tangledIssueComment.rev, issueComment.rev), 66 66 + }); 61 67 } 62 62 - } 68 68 + };

+35 -29

api/src/ingest/issueState.ts

reviewed

··· 7 7 export const ingestIssueState: CollectionHandler = async (issueStates) => { 8 8 for (const issueState of issueStates) { 9 9 if (issueState.action === "delete") { 10 10 - await db.insert(tangledIssueState).values({ 11 11 - did: issueState.did, 12 12 - rev: issueState.rev, 13 13 - rkey: issueState.rkey, 14 14 - cid: null, 15 15 - deleted: true, 16 16 - }).onConflictDoUpdate({ 17 17 - target: [tangledIssueState.did, tangledIssueState.rkey], 18 18 - set: { 10 10 + await db 11 11 + .insert(tangledIssueState) 12 12 + .values({ 13 13 + did: issueState.did, 19 14 rev: issueState.rev, 15 15 + rkey: issueState.rkey, 20 16 cid: null, 21 21 - deleted: true 22 22 - }, 23 23 - setWhere: lt(tangledIssueState.rev, issueState.rev) 24 24 - }); 17 17 + deleted: true, 18 18 + }) 19 19 + .onConflictDoUpdate({ 20 20 + target: [tangledIssueState.did, tangledIssueState.rkey], 21 21 + set: { 22 22 + rev: issueState.rev, 23 23 + cid: null, 24 24 + deleted: true, 25 25 + }, 26 26 + setWhere: lt(tangledIssueState.rev, issueState.rev), 27 27 + }); 25 28 continue; 26 29 } 27 30 ··· 29 32 if (!validatedRecord.success) continue; 30 33 const { value: issueStateRecord } = validatedRecord; 31 34 32 32 - await db.insert(tangledIssueState).values({ 33 33 - did: issueState.did, 34 34 - rev: issueState.rev, 35 35 - rkey: issueState.rkey, 36 36 - cid: issueState.cid, 37 37 - deleted: false, 38 38 - 39 39 - issue: issueStateRecord.issue, 40 40 - state: issueStateRecord.state, 41 41 - }).onConflictDoUpdate({ 42 42 - target: [tangledIssueState.did, tangledIssueState.rkey], 43 43 - set: { 35 35 + await db 36 36 + .insert(tangledIssueState) 37 37 + .values({ 38 38 + did: issueState.did, 44 39 rev: issueState.rev, 40 40 + rkey: issueState.rkey, 45 41 cid: issueState.cid, 46 42 deleted: false, 47 43 48 44 issue: issueStateRecord.issue, 49 45 state: issueStateRecord.state, 50 50 - }, 51 51 - setWhere: lt(tangledIssueState.rev, issueState.rev) 52 52 - }) 46 46 + }) 47 47 + .onConflictDoUpdate({ 48 48 + target: [tangledIssueState.did, tangledIssueState.rkey], 49 49 + set: { 50 50 + rev: issueState.rev, 51 51 + cid: issueState.cid, 52 52 + deleted: false, 53 53 + 54 54 + issue: issueStateRecord.issue, 55 55 + state: issueStateRecord.state, 56 56 + }, 57 57 + setWhere: lt(tangledIssueState.rev, issueState.rev), 58 58 + }); 53 59 } 54 54 - } 60 60 + };

+34 -28

api/src/ingest/knot.ts

reviewed

··· 7 7 export const ingestKnot: CollectionHandler = async (knots) => { 8 8 for (const knot of knots) { 9 9 if (knot.action === "delete") { 10 10 - await db.insert(tangledKnot).values({ 11 11 - did: knot.did, 12 12 - rev: knot.rev, 13 13 - rkey: knot.rkey, 14 14 - cid: null, 15 15 - deleted: true, 16 16 - }).onConflictDoUpdate({ 17 17 - target: [tangledKnot.did, tangledKnot.rkey], 18 18 - set: { 10 10 + await db 11 11 + .insert(tangledKnot) 12 12 + .values({ 13 13 + did: knot.did, 19 14 rev: knot.rev, 15 15 + rkey: knot.rkey, 20 16 cid: null, 21 21 - deleted: true 22 22 - }, 23 23 - setWhere: lt(tangledKnot.rev, knot.rev) 24 24 - }); 17 17 + deleted: true, 18 18 + }) 19 19 + .onConflictDoUpdate({ 20 20 + target: [tangledKnot.did, tangledKnot.rkey], 21 21 + set: { 22 22 + rev: knot.rev, 23 23 + cid: null, 24 24 + deleted: true, 25 25 + }, 26 26 + setWhere: lt(tangledKnot.rev, knot.rev), 27 27 + }); 25 28 continue; 26 29 } 27 30 ··· 29 32 if (!validatedRecord.success) continue; 30 33 const { value: knotRecord } = validatedRecord; 31 34 32 32 - await db.insert(tangledKnot).values({ 33 33 - did: knot.did, 34 34 - rev: knot.rev, 35 35 - rkey: knot.rkey, 36 36 - cid: knot.cid, 37 37 - deleted: false, 38 38 - 39 39 - createdAt: new Date(knotRecord.createdAt), 40 40 - }).onConflictDoUpdate({ 41 41 - target: [tangledKnot.did, tangledKnot.rkey], 42 42 - set: { 35 35 + await db 36 36 + .insert(tangledKnot) 37 37 + .values({ 38 38 + did: knot.did, 43 39 rev: knot.rev, 40 40 + rkey: knot.rkey, 44 41 cid: knot.cid, 45 42 deleted: false, 46 43 47 44 createdAt: new Date(knotRecord.createdAt), 48 48 - }, 49 49 - setWhere: lt(tangledKnot.rev, knot.rev) 50 50 - }) 45 45 + }) 46 46 + .onConflictDoUpdate({ 47 47 + target: [tangledKnot.did, tangledKnot.rkey], 48 48 + set: { 49 49 + rev: knot.rev, 50 50 + cid: knot.cid, 51 51 + deleted: false, 52 52 + 53 53 + createdAt: new Date(knotRecord.createdAt), 54 54 + }, 55 55 + setWhere: lt(tangledKnot.rev, knot.rev), 56 56 + }); 51 57 } 52 52 - } 58 58 + };

+36 -30

api/src/ingest/knotMember.ts

reviewed

··· 7 7 export const ingestKnotMember: CollectionHandler = async (knotMembers) => { 8 8 for (const knotMember of knotMembers) { 9 9 if (knotMember.action === "delete") { 10 10 - await db.insert(tangledKnotMember).values({ 11 11 - did: knotMember.did, 12 12 - rev: knotMember.rev, 13 13 - rkey: knotMember.rkey, 14 14 - cid: null, 15 15 - deleted: true, 16 16 - }).onConflictDoUpdate({ 17 17 - target: [tangledKnotMember.did, tangledKnotMember.rkey], 18 18 - set: { 10 10 + await db 11 11 + .insert(tangledKnotMember) 12 12 + .values({ 13 13 + did: knotMember.did, 19 14 rev: knotMember.rev, 15 15 + rkey: knotMember.rkey, 20 16 cid: null, 21 21 - deleted: true 22 22 - }, 23 23 - setWhere: lt(tangledKnotMember.rev, knotMember.rev) 24 24 - }); 17 17 + deleted: true, 18 18 + }) 19 19 + .onConflictDoUpdate({ 20 20 + target: [tangledKnotMember.did, tangledKnotMember.rkey], 21 21 + set: { 22 22 + rev: knotMember.rev, 23 23 + cid: null, 24 24 + deleted: true, 25 25 + }, 26 26 + setWhere: lt(tangledKnotMember.rev, knotMember.rev), 27 27 + }); 25 28 continue; 26 29 } 27 30 ··· 29 32 if (!validatedRecord.success) continue; 30 33 const { value: knotMemberRecord } = validatedRecord; 31 34 32 32 - await db.insert(tangledKnotMember).values({ 33 33 - did: knotMember.did, 34 34 - rev: knotMember.rev, 35 35 - rkey: knotMember.rkey, 36 36 - cid: knotMember.cid, 37 37 - deleted: false, 38 38 - 39 39 - subject: knotMemberRecord.subject, 40 40 - domain: knotMemberRecord.domain, 41 41 - createdAt: new Date(knotMemberRecord.createdAt), 42 42 - }).onConflictDoUpdate({ 43 43 - target: [tangledKnotMember.did, tangledKnotMember.rkey], 44 44 - set: { 35 35 + await db 36 36 + .insert(tangledKnotMember) 37 37 + .values({ 38 38 + did: knotMember.did, 45 39 rev: knotMember.rev, 40 40 + rkey: knotMember.rkey, 46 41 cid: knotMember.cid, 47 42 deleted: false, 48 43 49 44 subject: knotMemberRecord.subject, 50 45 domain: knotMemberRecord.domain, 51 46 createdAt: new Date(knotMemberRecord.createdAt), 52 52 - }, 53 53 - setWhere: lt(tangledKnotMember.rev, knotMember.rev) 54 54 - }) 47 47 + }) 48 48 + .onConflictDoUpdate({ 49 49 + target: [tangledKnotMember.did, tangledKnotMember.rkey], 50 50 + set: { 51 51 + rev: knotMember.rev, 52 52 + cid: knotMember.cid, 53 53 + deleted: false, 54 54 + 55 55 + subject: knotMemberRecord.subject, 56 56 + domain: knotMemberRecord.domain, 57 57 + createdAt: new Date(knotMemberRecord.createdAt), 58 58 + }, 59 59 + setWhere: lt(tangledKnotMember.rev, knotMember.rev), 60 60 + }); 55 61 } 56 56 - } 62 62 + };

+41 -35

api/src/ingest/labelDefinition.ts

reviewed

··· 7 7 export const ingestLabelDefinition: CollectionHandler = async (labelDefinitions) => { 8 8 for (const labelDefinition of labelDefinitions) { 9 9 if (labelDefinition.action === "delete") { 10 10 - await db.insert(tangledLabelDefinition).values({ 11 11 - did: labelDefinition.did, 12 12 - rev: labelDefinition.rev, 13 13 - rkey: labelDefinition.rkey, 14 14 - cid: null, 15 15 - deleted: true, 16 16 - }).onConflictDoUpdate({ 17 17 - target: [tangledLabelDefinition.did, tangledLabelDefinition.rkey], 18 18 - set: { 10 10 + await db 11 11 + .insert(tangledLabelDefinition) 12 12 + .values({ 13 13 + did: labelDefinition.did, 19 14 rev: labelDefinition.rev, 15 15 + rkey: labelDefinition.rkey, 20 16 cid: null, 21 21 - deleted: true 22 22 - }, 23 23 - setWhere: lt(tangledLabelDefinition.rev, labelDefinition.rev) 24 24 - }); 17 17 + deleted: true, 18 18 + }) 19 19 + .onConflictDoUpdate({ 20 20 + target: [tangledLabelDefinition.did, tangledLabelDefinition.rkey], 21 21 + set: { 22 22 + rev: labelDefinition.rev, 23 23 + cid: null, 24 24 + deleted: true, 25 25 + }, 26 26 + setWhere: lt(tangledLabelDefinition.rev, labelDefinition.rev), 27 27 + }); 25 28 continue; 26 29 } 27 30 ··· 29 32 if (!validatedRecord.success) continue; 30 33 const { value: labelDefinitionRecord } = validatedRecord; 31 34 32 32 - await db.insert(tangledLabelDefinition).values({ 33 33 - did: labelDefinition.did, 34 34 - rev: labelDefinition.rev, 35 35 - rkey: labelDefinition.rkey, 36 36 - cid: labelDefinition.cid, 37 37 - deleted: false, 38 38 - 39 39 - name: labelDefinitionRecord.name, 40 40 - valueType: labelDefinitionRecord.valueType.type, 41 41 - valueFormat: labelDefinitionRecord.valueType.format, 42 42 - valueEnum: labelDefinitionRecord.valueType.enum, 43 43 - scope: labelDefinitionRecord.scope, 44 44 - color: labelDefinitionRecord.color, 45 45 - createdAt: new Date(labelDefinitionRecord.createdAt), 46 46 - multiple: labelDefinitionRecord.multiple, 47 47 - }).onConflictDoUpdate({ 48 48 - target: [tangledLabelDefinition.did, tangledLabelDefinition.rkey], 49 49 - set: { 35 35 + await db 36 36 + .insert(tangledLabelDefinition) 37 37 + .values({ 38 38 + did: labelDefinition.did, 50 39 rev: labelDefinition.rev, 40 40 + rkey: labelDefinition.rkey, 51 41 cid: labelDefinition.cid, 52 42 deleted: false, 53 43 ··· 59 49 color: labelDefinitionRecord.color, 60 50 createdAt: new Date(labelDefinitionRecord.createdAt), 61 51 multiple: labelDefinitionRecord.multiple, 62 62 - }, 63 63 - setWhere: lt(tangledLabelDefinition.rev, labelDefinition.rev) 64 64 - }) 52 52 + }) 53 53 + .onConflictDoUpdate({ 54 54 + target: [tangledLabelDefinition.did, tangledLabelDefinition.rkey], 55 55 + set: { 56 56 + rev: labelDefinition.rev, 57 57 + cid: labelDefinition.cid, 58 58 + deleted: false, 59 59 + 60 60 + name: labelDefinitionRecord.name, 61 61 + valueType: labelDefinitionRecord.valueType.type, 62 62 + valueFormat: labelDefinitionRecord.valueType.format, 63 63 + valueEnum: labelDefinitionRecord.valueType.enum, 64 64 + scope: labelDefinitionRecord.scope, 65 65 + color: labelDefinitionRecord.color, 66 66 + createdAt: new Date(labelDefinitionRecord.createdAt), 67 67 + multiple: labelDefinitionRecord.multiple, 68 68 + }, 69 69 + setWhere: lt(tangledLabelDefinition.rev, labelDefinition.rev), 70 70 + }); 65 71 } 66 66 - } 72 72 + };

+37 -31

api/src/ingest/labelOp.ts

reviewed

··· 7 7 export const ingestLabelOp: CollectionHandler = async (labelOps) => { 8 8 for (const labelOp of labelOps) { 9 9 if (labelOp.action === "delete") { 10 10 - await db.insert(tangledLabelOp).values({ 11 11 - did: labelOp.did, 12 12 - rev: labelOp.rev, 13 13 - rkey: labelOp.rkey, 14 14 - cid: null, 15 15 - deleted: true, 16 16 - }).onConflictDoUpdate({ 17 17 - target: [tangledLabelOp.did, tangledLabelOp.rkey], 18 18 - set: { 10 10 + await db 11 11 + .insert(tangledLabelOp) 12 12 + .values({ 13 13 + did: labelOp.did, 19 14 rev: labelOp.rev, 15 15 + rkey: labelOp.rkey, 20 16 cid: null, 21 21 - deleted: true 22 22 - }, 23 23 - setWhere: lt(tangledLabelOp.rev, labelOp.rev) 24 24 - }); 17 17 + deleted: true, 18 18 + }) 19 19 + .onConflictDoUpdate({ 20 20 + target: [tangledLabelOp.did, tangledLabelOp.rkey], 21 21 + set: { 22 22 + rev: labelOp.rev, 23 23 + cid: null, 24 24 + deleted: true, 25 25 + }, 26 26 + setWhere: lt(tangledLabelOp.rev, labelOp.rev), 27 27 + }); 25 28 continue; 26 29 } 27 30 ··· 29 32 if (!validatedRecord.success) continue; 30 33 const { value: labelOpRecord } = validatedRecord; 31 34 32 32 - await db.insert(tangledLabelOp).values({ 33 33 - did: labelOp.did, 34 34 - rev: labelOp.rev, 35 35 - rkey: labelOp.rkey, 36 36 - cid: labelOp.cid, 37 37 - deleted: false, 38 38 - 39 39 - subject: labelOpRecord.subject, 40 40 - performedAt: new Date(labelOpRecord.performedAt), 41 41 - add: labelOpRecord.add, 42 42 - delete: labelOpRecord.delete, 43 43 - }).onConflictDoUpdate({ 44 44 - target: [tangledLabelOp.did, tangledLabelOp.rkey], 45 45 - set: { 35 35 + await db 36 36 + .insert(tangledLabelOp) 37 37 + .values({ 38 38 + did: labelOp.did, 46 39 rev: labelOp.rev, 40 40 + rkey: labelOp.rkey, 47 41 cid: labelOp.cid, 48 42 deleted: false, 49 43 ··· 51 45 performedAt: new Date(labelOpRecord.performedAt), 52 46 add: labelOpRecord.add, 53 47 delete: labelOpRecord.delete, 54 54 - }, 55 55 - setWhere: lt(tangledLabelOp.rev, labelOp.rev) 56 56 - }) 48 48 + }) 49 49 + .onConflictDoUpdate({ 50 50 + target: [tangledLabelOp.did, tangledLabelOp.rkey], 51 51 + set: { 52 52 + rev: labelOp.rev, 53 53 + cid: labelOp.cid, 54 54 + deleted: false, 55 55 + 56 56 + subject: labelOpRecord.subject, 57 57 + performedAt: new Date(labelOpRecord.performedAt), 58 58 + add: labelOpRecord.add, 59 59 + delete: labelOpRecord.delete, 60 60 + }, 61 61 + setWhere: lt(tangledLabelOp.rev, labelOp.rev), 62 62 + }); 57 63 } 58 58 - } 64 64 + };

+54 -44

api/src/ingest/pipeline.ts

reviewed

··· 7 7 export const ingestPipeline: CollectionHandler = async (pipelines) => { 8 8 for (const pipeline of pipelines) { 9 9 if (pipeline.action === "delete") { 10 10 - await db.insert(tangledPipeline).values({ 11 11 - did: pipeline.did, 12 12 - rev: pipeline.rev, 13 13 - rkey: pipeline.rkey, 14 14 - cid: null, 15 15 - deleted: true, 16 16 - }).onConflictDoUpdate({ 17 17 - target: [tangledPipeline.did, tangledPipeline.rkey], 18 18 - set: { 10 10 + await db 11 11 + .insert(tangledPipeline) 12 12 + .values({ 13 13 + did: pipeline.did, 19 14 rev: pipeline.rev, 15 15 + rkey: pipeline.rkey, 20 16 cid: null, 21 21 - deleted: true 22 22 - }, 23 23 - setWhere: lt(tangledPipeline.rev, pipeline.rev) 24 24 - }); 17 17 + deleted: true, 18 18 + }) 19 19 + .onConflictDoUpdate({ 20 20 + target: [tangledPipeline.did, tangledPipeline.rkey], 21 21 + set: { 22 22 + rev: pipeline.rev, 23 23 + cid: null, 24 24 + deleted: true, 25 25 + }, 26 26 + setWhere: lt(tangledPipeline.rev, pipeline.rev), 27 27 + }); 25 28 continue; 26 29 } 27 30 ··· 31 34 32 35 const manualInputs = pipelineRecord.triggerMetadata.manual?.inputs; 33 36 34 34 - await db.insert(tangledPipeline).values({ 35 35 - did: pipeline.did, 36 36 - rev: pipeline.rev, 37 37 - rkey: pipeline.rkey, 38 38 - cid: pipeline.cid, 39 39 - deleted: false, 40 40 - 41 41 - triggerMetadataKind: pipelineRecord.triggerMetadata.kind, 42 42 - triggerMetadataRepoKnot: pipelineRecord.triggerMetadata.repo.knot, 43 43 - triggerMetadataRepoDid: pipelineRecord.triggerMetadata.repo.did, 44 44 - triggerMetadataRepoRepoDid: pipelineRecord.triggerMetadata.repo.repoDid, 45 45 - triggerMetadataRepoRepo: pipelineRecord.triggerMetadata.repo.repo, 46 46 - triggerMetadataRepoDefaultBranch: pipelineRecord.triggerMetadata.repo.defaultBranch, 47 47 - triggerMetadataPushRef: pipelineRecord.triggerMetadata.push?.ref, 48 48 - triggerMetadataPushNewSha: pipelineRecord.triggerMetadata.push?.newSha, 49 49 - triggerMetadataPushOldSha: pipelineRecord.triggerMetadata.push?.oldSha, 50 50 - triggerMetadataPullSourceBranch: pipelineRecord.triggerMetadata.pullRequest?.sourceBranch, 51 51 - triggerMetadataPullTargetBranch: pipelineRecord.triggerMetadata.pullRequest?.targetBranch, 52 52 - triggerMetadataPullSourceSha: pipelineRecord.triggerMetadata.pullRequest?.sourceSha, 53 53 - triggerMetadataPullAction: pipelineRecord.triggerMetadata.pullRequest?.action, 54 54 - triggerMetadataManual: manualInputs ? manualInputs.map(({ key, value }) => ({ key, value })) : null, 55 55 - workflows: pipelineRecord.workflows, 56 56 - }).onConflictDoUpdate({ 57 57 - target: [tangledPipeline.did, tangledPipeline.rkey], 58 58 - set: { 37 37 + await db 38 38 + .insert(tangledPipeline) 39 39 + .values({ 40 40 + did: pipeline.did, 59 41 rev: pipeline.rev, 42 42 + rkey: pipeline.rkey, 60 43 cid: pipeline.cid, 61 44 deleted: false, 62 45 ··· 71 54 triggerMetadataPushOldSha: pipelineRecord.triggerMetadata.push?.oldSha, 72 55 triggerMetadataPullSourceBranch: pipelineRecord.triggerMetadata.pullRequest?.sourceBranch, 73 56 triggerMetadataPullTargetBranch: pipelineRecord.triggerMetadata.pullRequest?.targetBranch, 74 74 - triggerMetadataPullSourceSha: pipelineRecord.triggerMetadata.pullRequest?.sourceSha, 57 57 + triggerMetadataPullSourceSha: pipelineRecord.triggerMetadata.pullRequest?.sourceSha, 75 58 triggerMetadataPullAction: pipelineRecord.triggerMetadata.pullRequest?.action, 76 76 - triggerMetadataManual: manualInputs ? manualInputs.map(({ key, value }) => ({ key, value })) : null, 59 59 + triggerMetadataManual: manualInputs 60 60 + ? manualInputs.map(({ key, value }) => ({ key, value })) 61 61 + : null, 77 62 workflows: pipelineRecord.workflows, 78 78 - }, 79 79 - setWhere: lt(tangledPipeline.rev, pipeline.rev) 80 80 - }) 63 63 + }) 64 64 + .onConflictDoUpdate({ 65 65 + target: [tangledPipeline.did, tangledPipeline.rkey], 66 66 + set: { 67 67 + rev: pipeline.rev, 68 68 + cid: pipeline.cid, 69 69 + deleted: false, 70 70 + 71 71 + triggerMetadataKind: pipelineRecord.triggerMetadata.kind, 72 72 + triggerMetadataRepoKnot: pipelineRecord.triggerMetadata.repo.knot, 73 73 + triggerMetadataRepoDid: pipelineRecord.triggerMetadata.repo.did, 74 74 + triggerMetadataRepoRepoDid: pipelineRecord.triggerMetadata.repo.repoDid, 75 75 + triggerMetadataRepoRepo: pipelineRecord.triggerMetadata.repo.repo, 76 76 + triggerMetadataRepoDefaultBranch: pipelineRecord.triggerMetadata.repo.defaultBranch, 77 77 + triggerMetadataPushRef: pipelineRecord.triggerMetadata.push?.ref, 78 78 + triggerMetadataPushNewSha: pipelineRecord.triggerMetadata.push?.newSha, 79 79 + triggerMetadataPushOldSha: pipelineRecord.triggerMetadata.push?.oldSha, 80 80 + triggerMetadataPullSourceBranch: pipelineRecord.triggerMetadata.pullRequest?.sourceBranch, 81 81 + triggerMetadataPullTargetBranch: pipelineRecord.triggerMetadata.pullRequest?.targetBranch, 82 82 + triggerMetadataPullSourceSha: pipelineRecord.triggerMetadata.pullRequest?.sourceSha, 83 83 + triggerMetadataPullAction: pipelineRecord.triggerMetadata.pullRequest?.action, 84 84 + triggerMetadataManual: manualInputs 85 85 + ? manualInputs.map(({ key, value }) => ({ key, value })) 86 86 + : null, 87 87 + workflows: pipelineRecord.workflows, 88 88 + }, 89 89 + setWhere: lt(tangledPipeline.rev, pipeline.rev), 90 90 + }); 81 91 } 82 82 - } 92 92 + };

+39 -33

api/src/ingest/pipelineStatus.ts

reviewed

··· 7 7 export const ingestPipelineStatus: CollectionHandler = async (pipelineStatuses) => { 8 8 for (const pipelineStatus of pipelineStatuses) { 9 9 if (pipelineStatus.action === "delete") { 10 10 - await db.insert(tangledPipelineStatus).values({ 11 11 - did: pipelineStatus.did, 12 12 - rev: pipelineStatus.rev, 13 13 - rkey: pipelineStatus.rkey, 14 14 - cid: null, 15 15 - deleted: true, 16 16 - }).onConflictDoUpdate({ 17 17 - target: [tangledPipelineStatus.did, tangledPipelineStatus.rkey], 18 18 - set: { 10 10 + await db 11 11 + .insert(tangledPipelineStatus) 12 12 + .values({ 13 13 + did: pipelineStatus.did, 19 14 rev: pipelineStatus.rev, 15 15 + rkey: pipelineStatus.rkey, 20 16 cid: null, 21 21 - deleted: true 22 22 - }, 23 23 - setWhere: lt(tangledPipelineStatus.rev, pipelineStatus.rev) 24 24 - }); 17 17 + deleted: true, 18 18 + }) 19 19 + .onConflictDoUpdate({ 20 20 + target: [tangledPipelineStatus.did, tangledPipelineStatus.rkey], 21 21 + set: { 22 22 + rev: pipelineStatus.rev, 23 23 + cid: null, 24 24 + deleted: true, 25 25 + }, 26 26 + setWhere: lt(tangledPipelineStatus.rev, pipelineStatus.rev), 27 27 + }); 25 28 continue; 26 29 } 27 30 ··· 29 32 if (!validatedRecord.success) continue; 30 33 const { value: pipelineStatusRecord } = validatedRecord; 31 34 32 32 - await db.insert(tangledPipelineStatus).values({ 33 33 - did: pipelineStatus.did, 34 34 - rev: pipelineStatus.rev, 35 35 - rkey: pipelineStatus.rkey, 36 36 - cid: pipelineStatus.cid, 37 37 - deleted: false, 38 38 - 39 39 - pipeline: pipelineStatusRecord.pipeline, 40 40 - workflow: pipelineStatusRecord.workflow, 41 41 - status: pipelineStatusRecord.status, 42 42 - createdAt: new Date(pipelineStatusRecord.createdAt), 43 43 - error: pipelineStatusRecord.error, 44 44 - exitCode: pipelineStatusRecord.exitCode, 45 45 - }).onConflictDoUpdate({ 46 46 - target: [tangledPipelineStatus.did, tangledPipelineStatus.rkey], 47 47 - set: { 35 35 + await db 36 36 + .insert(tangledPipelineStatus) 37 37 + .values({ 38 38 + did: pipelineStatus.did, 48 39 rev: pipelineStatus.rev, 40 40 + rkey: pipelineStatus.rkey, 49 41 cid: pipelineStatus.cid, 50 42 deleted: false, 51 43 ··· 55 47 createdAt: new Date(pipelineStatusRecord.createdAt), 56 48 error: pipelineStatusRecord.error, 57 49 exitCode: pipelineStatusRecord.exitCode, 58 58 - }, 59 59 - setWhere: lt(tangledPipelineStatus.rev, pipelineStatus.rev) 60 60 - }) 50 50 + }) 51 51 + .onConflictDoUpdate({ 52 52 + target: [tangledPipelineStatus.did, tangledPipelineStatus.rkey], 53 53 + set: { 54 54 + rev: pipelineStatus.rev, 55 55 + cid: pipelineStatus.cid, 56 56 + deleted: false, 57 57 + 58 58 + pipeline: pipelineStatusRecord.pipeline, 59 59 + workflow: pipelineStatusRecord.workflow, 60 60 + status: pipelineStatusRecord.status, 61 61 + createdAt: new Date(pipelineStatusRecord.createdAt), 62 62 + error: pipelineStatusRecord.error, 63 63 + exitCode: pipelineStatusRecord.exitCode, 64 64 + }, 65 65 + setWhere: lt(tangledPipelineStatus.rev, pipelineStatus.rev), 66 66 + }); 61 67 } 62 62 - } 68 68 + };

+40 -34

api/src/ingest/profile.ts

reviewed

··· 8 8 export const ingestProfile: CollectionHandler = async (profiles) => { 9 9 for (const profile of profiles) { 10 10 if (profile.action === "delete") { 11 11 - await db.insert(tangledProfile).values({ 12 12 - did: profile.did, 13 13 - rev: profile.rev, 14 14 - cid: null, 15 15 - deleted: true, 16 16 - }).onConflictDoUpdate({ 17 17 - target: tangledProfile.did, 18 18 - set: { 11 11 + await db 12 12 + .insert(tangledProfile) 13 13 + .values({ 14 14 + did: profile.did, 19 15 rev: profile.rev, 20 16 cid: null, 21 21 - deleted: true 22 22 - }, 23 23 - setWhere: lt(tangledProfile.rev, profile.rev) 24 24 - }); 17 17 + deleted: true, 18 18 + }) 19 19 + .onConflictDoUpdate({ 20 20 + target: tangledProfile.did, 21 21 + set: { 22 22 + rev: profile.rev, 23 23 + cid: null, 24 24 + deleted: true, 25 25 + }, 26 26 + setWhere: lt(tangledProfile.rev, profile.rev), 27 27 + }); 25 28 continue; 26 29 } 27 30 ··· 31 34 32 35 const avatar = profileRecord.avatar ? getBlobCidString(profileRecord.avatar) : null; 33 36 34 34 - await db.insert(tangledProfile).values({ 35 35 - did: profile.did, 36 36 - rev: profile.rev, 37 37 - cid: profile.cid, 38 38 - deleted: false, 39 39 - 40 40 - avatar, 41 41 - description: profileRecord.description, 42 42 - links: profileRecord.links, 43 43 - stats: profileRecord.stats, 44 44 - bluesky: profileRecord.bluesky, 45 45 - location: profileRecord.location, 46 46 - pinnedRepositories: profileRecord.pinnedRepositories, 47 47 - pronouns: profileRecord.pronouns, 48 48 - preferredHandle: profileRecord.preferredHandle, 49 49 - }).onConflictDoUpdate({ 50 50 - target: tangledProfile.did, 51 51 - set: { 37 37 + await db 38 38 + .insert(tangledProfile) 39 39 + .values({ 40 40 + did: profile.did, 52 41 rev: profile.rev, 53 42 cid: profile.cid, 54 43 deleted: false, ··· 62 51 pinnedRepositories: profileRecord.pinnedRepositories, 63 52 pronouns: profileRecord.pronouns, 64 53 preferredHandle: profileRecord.preferredHandle, 65 65 - }, 66 66 - setWhere: lt(tangledProfile.rev, profile.rev) 67 67 - }) 54 54 + }) 55 55 + .onConflictDoUpdate({ 56 56 + target: tangledProfile.did, 57 57 + set: { 58 58 + rev: profile.rev, 59 59 + cid: profile.cid, 60 60 + deleted: false, 61 61 + 62 62 + avatar, 63 63 + description: profileRecord.description, 64 64 + links: profileRecord.links, 65 65 + stats: profileRecord.stats, 66 66 + bluesky: profileRecord.bluesky, 67 67 + location: profileRecord.location, 68 68 + pinnedRepositories: profileRecord.pinnedRepositories, 69 69 + pronouns: profileRecord.pronouns, 70 70 + preferredHandle: profileRecord.preferredHandle, 71 71 + }, 72 72 + setWhere: lt(tangledProfile.rev, profile.rev), 73 73 + }); 68 74 } 69 69 - } 75 75 + };

+36 -30

api/src/ingest/publicKey.ts

reviewed

··· 7 7 export const ingestPublicKey: CollectionHandler = async (publicKeys) => { 8 8 for (const publicKey of publicKeys) { 9 9 if (publicKey.action === "delete") { 10 10 - await db.insert(tangledPublicKey).values({ 11 11 - did: publicKey.did, 12 12 - rev: publicKey.rev, 13 13 - rkey: publicKey.rkey, 14 14 - cid: null, 15 15 - deleted: true, 16 16 - }).onConflictDoUpdate({ 17 17 - target: [tangledPublicKey.did, tangledPublicKey.rkey], 18 18 - set: { 10 10 + await db 11 11 + .insert(tangledPublicKey) 12 12 + .values({ 13 13 + did: publicKey.did, 19 14 rev: publicKey.rev, 15 15 + rkey: publicKey.rkey, 20 16 cid: null, 21 21 - deleted: true 22 22 - }, 23 23 - setWhere: lt(tangledPublicKey.rev, publicKey.rev) 24 24 - }); 17 17 + deleted: true, 18 18 + }) 19 19 + .onConflictDoUpdate({ 20 20 + target: [tangledPublicKey.did, tangledPublicKey.rkey], 21 21 + set: { 22 22 + rev: publicKey.rev, 23 23 + cid: null, 24 24 + deleted: true, 25 25 + }, 26 26 + setWhere: lt(tangledPublicKey.rev, publicKey.rev), 27 27 + }); 25 28 continue; 26 29 } 27 30 ··· 29 32 if (!validatedRecord.success) continue; 30 33 const { value: publicKeyRecord } = validatedRecord; 31 34 32 32 - await db.insert(tangledPublicKey).values({ 33 33 - did: publicKey.did, 34 34 - rev: publicKey.rev, 35 35 - rkey: publicKey.rkey, 36 36 - cid: publicKey.cid, 37 37 - deleted: false, 38 38 - 39 39 - key: publicKeyRecord.key, 40 40 - name: publicKeyRecord.name, 41 41 - createdAt: new Date(publicKeyRecord.createdAt), 42 42 - }).onConflictDoUpdate({ 43 43 - target: [tangledPublicKey.did, tangledPublicKey.rkey], 44 44 - set: { 35 35 + await db 36 36 + .insert(tangledPublicKey) 37 37 + .values({ 38 38 + did: publicKey.did, 45 39 rev: publicKey.rev, 40 40 + rkey: publicKey.rkey, 46 41 cid: publicKey.cid, 47 42 deleted: false, 48 43 49 44 key: publicKeyRecord.key, 50 45 name: publicKeyRecord.name, 51 46 createdAt: new Date(publicKeyRecord.createdAt), 52 52 - }, 53 53 - setWhere: lt(tangledPublicKey.rev, publicKey.rev) 54 54 - }) 47 47 + }) 48 48 + .onConflictDoUpdate({ 49 49 + target: [tangledPublicKey.did, tangledPublicKey.rkey], 50 50 + set: { 51 51 + rev: publicKey.rev, 52 52 + cid: publicKey.cid, 53 53 + deleted: false, 54 54 + 55 55 + key: publicKeyRecord.key, 56 56 + name: publicKeyRecord.name, 57 57 + createdAt: new Date(publicKeyRecord.createdAt), 58 58 + }, 59 59 + setWhere: lt(tangledPublicKey.rev, publicKey.rev), 60 60 + }); 55 61 } 56 56 - } 62 62 + };

+46 -40

api/src/ingest/pull.ts

reviewed

··· 7 7 export const ingestPull: CollectionHandler = async (pulls) => { 8 8 for (const pull of pulls) { 9 9 if (pull.action === "delete") { 10 10 - await db.insert(tangledPull).values({ 11 11 - did: pull.did, 12 12 - rev: pull.rev, 13 13 - rkey: pull.rkey, 14 14 - cid: null, 15 15 - deleted: true, 16 16 - }).onConflictDoUpdate({ 17 17 - target: [tangledPull.did, tangledPull.rkey], 18 18 - set: { 10 10 + await db 11 11 + .insert(tangledPull) 12 12 + .values({ 13 13 + did: pull.did, 19 14 rev: pull.rev, 15 15 + rkey: pull.rkey, 20 16 cid: null, 21 21 - deleted: true 22 22 - }, 23 23 - setWhere: lt(tangledPull.rev, pull.rev) 24 24 - }); 17 17 + deleted: true, 18 18 + }) 19 19 + .onConflictDoUpdate({ 20 20 + target: [tangledPull.did, tangledPull.rkey], 21 21 + set: { 22 22 + rev: pull.rev, 23 23 + cid: null, 24 24 + deleted: true, 25 25 + }, 26 26 + setWhere: lt(tangledPull.rev, pull.rev), 27 27 + }); 25 28 continue; 26 29 } 27 30 ··· 29 32 if (!validatedRecord.success) continue; 30 33 const { value: pullRecord } = validatedRecord; 31 34 32 32 - await db.insert(tangledPull).values({ 33 33 - did: pull.did, 34 34 - rev: pull.rev, 35 35 - rkey: pull.rkey, 36 36 - cid: pull.cid, 37 37 - deleted: false, 38 38 - 39 39 - title: pullRecord.title, 40 40 - body: pullRecord.body, 41 41 - rounds: pullRecord.rounds, 42 42 - sourceBranch: pullRecord.source?.branch, 43 43 - sourceRepo: pullRecord.source?.repo, 44 44 - sourceRepoDid: pullRecord.source?.repoDid, 45 45 - targetBranch: pullRecord.target?.branch, 46 46 - targetRepo: pullRecord.target?.repo, 47 47 - targetRepoDid: pullRecord.target?.repoDid, 48 48 - createdAt: new Date(pullRecord.createdAt), 49 49 - mentions: pullRecord.mentions, 50 50 - references: pullRecord.references, 51 51 - dependentOn: pullRecord.dependentOn, 52 52 - }).onConflictDoUpdate({ 53 53 - target: [tangledPull.did, tangledPull.rkey], 54 54 - set: { 35 35 + await db 36 36 + .insert(tangledPull) 37 37 + .values({ 38 38 + did: pull.did, 55 39 rev: pull.rev, 40 40 + rkey: pull.rkey, 56 41 cid: pull.cid, 57 42 deleted: false, 58 43 ··· 69 54 mentions: pullRecord.mentions, 70 55 references: pullRecord.references, 71 56 dependentOn: pullRecord.dependentOn, 72 72 - }, 73 73 - setWhere: lt(tangledPull.rev, pull.rev) 74 74 - }) 57 57 + }) 58 58 + .onConflictDoUpdate({ 59 59 + target: [tangledPull.did, tangledPull.rkey], 60 60 + set: { 61 61 + rev: pull.rev, 62 62 + cid: pull.cid, 63 63 + deleted: false, 64 64 + 65 65 + title: pullRecord.title, 66 66 + body: pullRecord.body, 67 67 + rounds: pullRecord.rounds, 68 68 + sourceBranch: pullRecord.source?.branch, 69 69 + sourceRepo: pullRecord.source?.repo, 70 70 + sourceRepoDid: pullRecord.source?.repoDid, 71 71 + targetBranch: pullRecord.target?.branch, 72 72 + targetRepo: pullRecord.target?.repo, 73 73 + targetRepoDid: pullRecord.target?.repoDid, 74 74 + createdAt: new Date(pullRecord.createdAt), 75 75 + mentions: pullRecord.mentions, 76 76 + references: pullRecord.references, 77 77 + dependentOn: pullRecord.dependentOn, 78 78 + }, 79 79 + setWhere: lt(tangledPull.rev, pull.rev), 80 80 + }); 75 81 } 76 76 - } 82 82 + };

+38 -32

api/src/ingest/pullComment.ts

reviewed

··· 7 7 export const ingestPullComment: CollectionHandler = async (pullComments) => { 8 8 for (const pullComment of pullComments) { 9 9 if (pullComment.action === "delete") { 10 10 - await db.insert(tangledPullComment).values({ 11 11 - did: pullComment.did, 12 12 - rev: pullComment.rev, 13 13 - rkey: pullComment.rkey, 14 14 - cid: null, 15 15 - deleted: true, 16 16 - }).onConflictDoUpdate({ 17 17 - target: [tangledPullComment.did, tangledPullComment.rkey], 18 18 - set: { 10 10 + await db 11 11 + .insert(tangledPullComment) 12 12 + .values({ 13 13 + did: pullComment.did, 19 14 rev: pullComment.rev, 15 15 + rkey: pullComment.rkey, 20 16 cid: null, 21 21 - deleted: true 22 22 - }, 23 23 - setWhere: lt(tangledPullComment.rev, pullComment.rev) 24 24 - }); 17 17 + deleted: true, 18 18 + }) 19 19 + .onConflictDoUpdate({ 20 20 + target: [tangledPullComment.did, tangledPullComment.rkey], 21 21 + set: { 22 22 + rev: pullComment.rev, 23 23 + cid: null, 24 24 + deleted: true, 25 25 + }, 26 26 + setWhere: lt(tangledPullComment.rev, pullComment.rev), 27 27 + }); 25 28 continue; 26 29 } 27 30 ··· 29 32 if (!validatedRecord.success) continue; 30 33 const { value: pullCommentRecord } = validatedRecord; 31 34 32 32 - await db.insert(tangledPullComment).values({ 33 33 - did: pullComment.did, 34 34 - rev: pullComment.rev, 35 35 - rkey: pullComment.rkey, 36 36 - cid: pullComment.cid, 37 37 - deleted: false, 38 38 - 39 39 - pull: pullCommentRecord.pull, 40 40 - body: pullCommentRecord.body, 41 41 - createdAt: new Date(pullCommentRecord.createdAt), 42 42 - mentions: pullCommentRecord.mentions, 43 43 - references: pullCommentRecord.references, 44 44 - }).onConflictDoUpdate({ 45 45 - target: [tangledPullComment.did, tangledPullComment.rkey], 46 46 - set: { 35 35 + await db 36 36 + .insert(tangledPullComment) 37 37 + .values({ 38 38 + did: pullComment.did, 47 39 rev: pullComment.rev, 40 40 + rkey: pullComment.rkey, 48 41 cid: pullComment.cid, 49 42 deleted: false, 50 43 ··· 53 46 createdAt: new Date(pullCommentRecord.createdAt), 54 47 mentions: pullCommentRecord.mentions, 55 48 references: pullCommentRecord.references, 56 56 - }, 57 57 - setWhere: lt(tangledPullComment.rev, pullComment.rev) 58 58 - }) 49 49 + }) 50 50 + .onConflictDoUpdate({ 51 51 + target: [tangledPullComment.did, tangledPullComment.rkey], 52 52 + set: { 53 53 + rev: pullComment.rev, 54 54 + cid: pullComment.cid, 55 55 + deleted: false, 56 56 + 57 57 + pull: pullCommentRecord.pull, 58 58 + body: pullCommentRecord.body, 59 59 + createdAt: new Date(pullCommentRecord.createdAt), 60 60 + mentions: pullCommentRecord.mentions, 61 61 + references: pullCommentRecord.references, 62 62 + }, 63 63 + setWhere: lt(tangledPullComment.rev, pullComment.rev), 64 64 + }); 59 65 } 60 60 - } 66 66 + };

+35 -29

api/src/ingest/pullStatus.ts

reviewed

··· 7 7 export const ingestPullStatus: CollectionHandler = async (pullStatuses) => { 8 8 for (const pullStatus of pullStatuses) { 9 9 if (pullStatus.action === "delete") { 10 10 - await db.insert(tangledPullStatus).values({ 11 11 - did: pullStatus.did, 12 12 - rev: pullStatus.rev, 13 13 - rkey: pullStatus.rkey, 14 14 - cid: null, 15 15 - deleted: true, 16 16 - }).onConflictDoUpdate({ 17 17 - target: [tangledPullStatus.did, tangledPullStatus.rkey], 18 18 - set: { 10 10 + await db 11 11 + .insert(tangledPullStatus) 12 12 + .values({ 13 13 + did: pullStatus.did, 19 14 rev: pullStatus.rev, 15 15 + rkey: pullStatus.rkey, 20 16 cid: null, 21 21 - deleted: true 22 22 - }, 23 23 - setWhere: lt(tangledPullStatus.rev, pullStatus.rev) 24 24 - }); 17 17 + deleted: true, 18 18 + }) 19 19 + .onConflictDoUpdate({ 20 20 + target: [tangledPullStatus.did, tangledPullStatus.rkey], 21 21 + set: { 22 22 + rev: pullStatus.rev, 23 23 + cid: null, 24 24 + deleted: true, 25 25 + }, 26 26 + setWhere: lt(tangledPullStatus.rev, pullStatus.rev), 27 27 + }); 25 28 continue; 26 29 } 27 30 ··· 29 32 if (!validatedRecord.success) continue; 30 33 const { value: pullStatusRecord } = validatedRecord; 31 34 32 32 - await db.insert(tangledPullStatus).values({ 33 33 - did: pullStatus.did, 34 34 - rev: pullStatus.rev, 35 35 - rkey: pullStatus.rkey, 36 36 - cid: pullStatus.cid, 37 37 - deleted: false, 38 38 - 39 39 - pull: pullStatusRecord.pull, 40 40 - status: pullStatusRecord.status, 41 41 - }).onConflictDoUpdate({ 42 42 - target: [tangledPullStatus.did, tangledPullStatus.rkey], 43 43 - set: { 35 35 + await db 36 36 + .insert(tangledPullStatus) 37 37 + .values({ 38 38 + did: pullStatus.did, 44 39 rev: pullStatus.rev, 40 40 + rkey: pullStatus.rkey, 45 41 cid: pullStatus.cid, 46 42 deleted: false, 47 43 48 44 pull: pullStatusRecord.pull, 49 45 status: pullStatusRecord.status, 50 50 - }, 51 51 - setWhere: lt(tangledPullStatus.rev, pullStatus.rev) 52 52 - }) 46 46 + }) 47 47 + .onConflictDoUpdate({ 48 48 + target: [tangledPullStatus.did, tangledPullStatus.rkey], 49 49 + set: { 50 50 + rev: pullStatus.rev, 51 51 + cid: pullStatus.cid, 52 52 + deleted: false, 53 53 + 54 54 + pull: pullStatusRecord.pull, 55 55 + status: pullStatusRecord.status, 56 56 + }, 57 57 + setWhere: lt(tangledPullStatus.rev, pullStatus.rev), 58 58 + }); 53 59 } 54 54 - } 60 60 + };

+36 -30

api/src/ingest/reaction.ts

reviewed

··· 7 7 export const ingestReaction: CollectionHandler = async (reactions) => { 8 8 for (const reaction of reactions) { 9 9 if (reaction.action === "delete") { 10 10 - await db.insert(tangledReaction).values({ 11 11 - did: reaction.did, 12 12 - rev: reaction.rev, 13 13 - rkey: reaction.rkey, 14 14 - cid: null, 15 15 - deleted: true, 16 16 - }).onConflictDoUpdate({ 17 17 - target: [tangledReaction.did, tangledReaction.rkey], 18 18 - set: { 10 10 + await db 11 11 + .insert(tangledReaction) 12 12 + .values({ 13 13 + did: reaction.did, 19 14 rev: reaction.rev, 15 15 + rkey: reaction.rkey, 20 16 cid: null, 21 21 - deleted: true 22 22 - }, 23 23 - setWhere: lt(tangledReaction.rev, reaction.rev) 24 24 - }); 17 17 + deleted: true, 18 18 + }) 19 19 + .onConflictDoUpdate({ 20 20 + target: [tangledReaction.did, tangledReaction.rkey], 21 21 + set: { 22 22 + rev: reaction.rev, 23 23 + cid: null, 24 24 + deleted: true, 25 25 + }, 26 26 + setWhere: lt(tangledReaction.rev, reaction.rev), 27 27 + }); 25 28 continue; 26 29 } 27 30 ··· 29 32 if (!validatedRecord.success) continue; 30 33 const { value: reactionRecord } = validatedRecord; 31 34 32 32 - await db.insert(tangledReaction).values({ 33 33 - did: reaction.did, 34 34 - rev: reaction.rev, 35 35 - rkey: reaction.rkey, 36 36 - cid: reaction.cid, 37 37 - deleted: false, 38 38 - 39 39 - subject: reactionRecord.subject, 40 40 - reaction: reactionRecord.reaction, 41 41 - createdAt: new Date(reactionRecord.createdAt), 42 42 - }).onConflictDoUpdate({ 43 43 - target: [tangledReaction.did, tangledReaction.rkey], 44 44 - set: { 35 35 + await db 36 36 + .insert(tangledReaction) 37 37 + .values({ 38 38 + did: reaction.did, 45 39 rev: reaction.rev, 40 40 + rkey: reaction.rkey, 46 41 cid: reaction.cid, 47 42 deleted: false, 48 43 49 44 subject: reactionRecord.subject, 50 45 reaction: reactionRecord.reaction, 51 46 createdAt: new Date(reactionRecord.createdAt), 52 52 - }, 53 53 - setWhere: lt(tangledReaction.rev, reaction.rev) 54 54 - }) 47 47 + }) 48 48 + .onConflictDoUpdate({ 49 49 + target: [tangledReaction.did, tangledReaction.rkey], 50 50 + set: { 51 51 + rev: reaction.rev, 52 52 + cid: reaction.cid, 53 53 + deleted: false, 54 54 + 55 55 + subject: reactionRecord.subject, 56 56 + reaction: reactionRecord.reaction, 57 57 + createdAt: new Date(reactionRecord.createdAt), 58 58 + }, 59 59 + setWhere: lt(tangledReaction.rev, reaction.rev), 60 60 + }); 55 61 } 56 56 - } 62 62 + };

+43 -37

api/src/ingest/refUpdate.ts

reviewed

··· 7 7 export const ingestRefUpdate: CollectionHandler = async (refUpdates) => { 8 8 for (const refUpdate of refUpdates) { 9 9 if (refUpdate.action === "delete") { 10 10 - await db.insert(tangledRefUpdate).values({ 11 11 - did: refUpdate.did, 12 12 - rev: refUpdate.rev, 13 13 - rkey: refUpdate.rkey, 14 14 - cid: null, 15 15 - deleted: true, 16 16 - }).onConflictDoUpdate({ 17 17 - target: [tangledRefUpdate.did, tangledRefUpdate.rkey], 18 18 - set: { 10 10 + await db 11 11 + .insert(tangledRefUpdate) 12 12 + .values({ 13 13 + did: refUpdate.did, 19 14 rev: refUpdate.rev, 15 15 + rkey: refUpdate.rkey, 20 16 cid: null, 21 21 - deleted: true 22 22 - }, 23 23 - setWhere: lt(tangledRefUpdate.rev, refUpdate.rev) 24 24 - }); 17 17 + deleted: true, 18 18 + }) 19 19 + .onConflictDoUpdate({ 20 20 + target: [tangledRefUpdate.did, tangledRefUpdate.rkey], 21 21 + set: { 22 22 + rev: refUpdate.rev, 23 23 + cid: null, 24 24 + deleted: true, 25 25 + }, 26 26 + setWhere: lt(tangledRefUpdate.rev, refUpdate.rev), 27 27 + }); 25 28 continue; 26 29 } 27 30 ··· 29 32 if (!validatedRecord.success) continue; 30 33 const { value: refUpdateRecord } = validatedRecord; 31 34 32 32 - await db.insert(tangledRefUpdate).values({ 33 33 - did: refUpdate.did, 34 34 - rev: refUpdate.rev, 35 35 - rkey: refUpdate.rkey, 36 36 - cid: refUpdate.cid, 37 37 - deleted: false, 38 38 - 39 39 - ref: refUpdateRecord.ref, 40 40 - committerDid: refUpdateRecord.committerDid, 41 41 - ownerDid: refUpdateRecord.ownerDid, 42 42 - repoDid: refUpdateRecord.repoDid, 43 43 - repoName: refUpdateRecord.repoName, 44 44 - oldSha: refUpdateRecord.oldSha, 45 45 - newSha: refUpdateRecord.newSha, 46 46 - metaIsDefaultRef: refUpdateRecord.meta.isDefaultRef, 47 47 - metaLangBreakdown: refUpdateRecord.meta.langBreakdown, 48 48 - metaCommitCount: refUpdateRecord.meta.commitCount, 49 49 - }).onConflictDoUpdate({ 50 50 - target: [tangledRefUpdate.did, tangledRefUpdate.rkey], 51 51 - set: { 35 35 + await db 36 36 + .insert(tangledRefUpdate) 37 37 + .values({ 38 38 + did: refUpdate.did, 52 39 rev: refUpdate.rev, 40 40 + rkey: refUpdate.rkey, 53 41 cid: refUpdate.cid, 54 42 deleted: false, 55 43 ··· 63 51 metaIsDefaultRef: refUpdateRecord.meta.isDefaultRef, 64 52 metaLangBreakdown: refUpdateRecord.meta.langBreakdown, 65 53 metaCommitCount: refUpdateRecord.meta.commitCount, 66 66 - }, 67 67 - setWhere: lt(tangledRefUpdate.rev, refUpdate.rev) 68 68 - }) 54 54 + }) 55 55 + .onConflictDoUpdate({ 56 56 + target: [tangledRefUpdate.did, tangledRefUpdate.rkey], 57 57 + set: { 58 58 + rev: refUpdate.rev, 59 59 + cid: refUpdate.cid, 60 60 + deleted: false, 61 61 + 62 62 + ref: refUpdateRecord.ref, 63 63 + committerDid: refUpdateRecord.committerDid, 64 64 + ownerDid: refUpdateRecord.ownerDid, 65 65 + repoDid: refUpdateRecord.repoDid, 66 66 + repoName: refUpdateRecord.repoName, 67 67 + oldSha: refUpdateRecord.oldSha, 68 68 + newSha: refUpdateRecord.newSha, 69 69 + metaIsDefaultRef: refUpdateRecord.meta.isDefaultRef, 70 70 + metaLangBreakdown: refUpdateRecord.meta.langBreakdown, 71 71 + metaCommitCount: refUpdateRecord.meta.commitCount, 72 72 + }, 73 73 + setWhere: lt(tangledRefUpdate.rev, refUpdate.rev), 74 74 + }); 69 75 } 70 70 - } 76 76 + };

+43 -37

api/src/ingest/repo.ts

reviewed

··· 8 8 export const ingestRepo: CollectionHandler = async (repos) => { 9 9 for (const repo of repos) { 10 10 if (repo.action === "delete") { 11 11 - await db.insert(tangledRepo).values({ 12 12 - did: repo.did, 13 13 - rev: repo.rev, 14 14 - rkey: repo.rkey, 15 15 - cid: null, 16 16 - deleted: true, 17 17 - }).onConflictDoUpdate({ 18 18 - target: [tangledRepo.did, tangledRepo.rkey], 19 19 - set: { 11 11 + await db 12 12 + .insert(tangledRepo) 13 13 + .values({ 14 14 + did: repo.did, 20 15 rev: repo.rev, 16 16 + rkey: repo.rkey, 21 17 cid: null, 22 22 - deleted: true 23 23 - }, 24 24 - setWhere: lt(tangledRepo.rev, repo.rev) 25 25 - }); 18 18 + deleted: true, 19 19 + }) 20 20 + .onConflictDoUpdate({ 21 21 + target: [tangledRepo.did, tangledRepo.rkey], 22 22 + set: { 23 23 + rev: repo.rev, 24 24 + cid: null, 25 25 + deleted: true, 26 26 + }, 27 27 + setWhere: lt(tangledRepo.rev, repo.rev), 28 28 + }); 26 29 continue; 27 30 } 28 31 ··· 30 33 if (!validatedRecord.success) continue; 31 34 const { value: repoRecord } = validatedRecord; 32 35 33 33 - await db.insert(tangledRepo).values({ 34 34 - did: repo.did, 35 35 - rev: repo.rev, 36 36 - rkey: repo.rkey, 37 37 - cid: repo.cid, 38 38 - deleted: false, 39 39 - 40 40 - name: repoRecord.name, 41 41 - knot: repoRecord.knot, 42 42 - spindle: repoRecord.spindle, 43 43 - description: repoRecord.description, 44 44 - website: repoRecord.website, 45 45 - topics: repoRecord.topics, 46 46 - source: repoRecord.source, 47 47 - labels: repoRecord.labels, 48 48 - repoDid: repoRecord.repoDid, 49 49 - createdAt: new Date(repoRecord.createdAt), 50 50 - }).onConflictDoUpdate({ 51 51 - target: [tangledRepo.did, tangledRepo.rkey], 52 52 - set: { 36 36 + await db 37 37 + .insert(tangledRepo) 38 38 + .values({ 39 39 + did: repo.did, 53 40 rev: repo.rev, 41 41 + rkey: repo.rkey, 54 42 cid: repo.cid, 55 43 deleted: false, 56 44 ··· 64 52 labels: repoRecord.labels, 65 53 repoDid: repoRecord.repoDid, 66 54 createdAt: new Date(repoRecord.createdAt), 67 67 - }, 68 68 - setWhere: lt(tangledRepo.rev, repo.rev) 69 69 - }) 55 55 + }) 56 56 + .onConflictDoUpdate({ 57 57 + target: [tangledRepo.did, tangledRepo.rkey], 58 58 + set: { 59 59 + rev: repo.rev, 60 60 + cid: repo.cid, 61 61 + deleted: false, 62 62 + 63 63 + name: repoRecord.name, 64 64 + knot: repoRecord.knot, 65 65 + spindle: repoRecord.spindle, 66 66 + description: repoRecord.description, 67 67 + website: repoRecord.website, 68 68 + topics: repoRecord.topics, 69 69 + source: repoRecord.source, 70 70 + labels: repoRecord.labels, 71 71 + repoDid: repoRecord.repoDid, 72 72 + createdAt: new Date(repoRecord.createdAt), 73 73 + }, 74 74 + setWhere: lt(tangledRepo.rev, repo.rev), 75 75 + }); 70 76 } 71 71 - } 77 77 + };

+34 -28

api/src/ingest/spindle.ts

reviewed

··· 7 7 export const ingestSpindle: CollectionHandler = async (spindles) => { 8 8 for (const spindle of spindles) { 9 9 if (spindle.action === "delete") { 10 10 - await db.insert(tangledSpindle).values({ 11 11 - did: spindle.did, 12 12 - rev: spindle.rev, 13 13 - rkey: spindle.rkey, 14 14 - cid: null, 15 15 - deleted: true, 16 16 - }).onConflictDoUpdate({ 17 17 - target: [tangledSpindle.did, tangledSpindle.rkey], 18 18 - set: { 10 10 + await db 11 11 + .insert(tangledSpindle) 12 12 + .values({ 13 13 + did: spindle.did, 19 14 rev: spindle.rev, 15 15 + rkey: spindle.rkey, 20 16 cid: null, 21 21 - deleted: true 22 22 - }, 23 23 - setWhere: lt(tangledSpindle.rev, spindle.rev) 24 24 - }); 17 17 + deleted: true, 18 18 + }) 19 19 + .onConflictDoUpdate({ 20 20 + target: [tangledSpindle.did, tangledSpindle.rkey], 21 21 + set: { 22 22 + rev: spindle.rev, 23 23 + cid: null, 24 24 + deleted: true, 25 25 + }, 26 26 + setWhere: lt(tangledSpindle.rev, spindle.rev), 27 27 + }); 25 28 continue; 26 29 } 27 30 ··· 29 32 if (!validatedRecord.success) continue; 30 33 const { value: spindleRecord } = validatedRecord; 31 34 32 32 - await db.insert(tangledSpindle).values({ 33 33 - did: spindle.did, 34 34 - rev: spindle.rev, 35 35 - rkey: spindle.rkey, 36 36 - cid: spindle.cid, 37 37 - deleted: false, 38 38 - 39 39 - createdAt: new Date(spindleRecord.createdAt), 40 40 - }).onConflictDoUpdate({ 41 41 - target: [tangledSpindle.did, tangledSpindle.rkey], 42 42 - set: { 35 35 + await db 36 36 + .insert(tangledSpindle) 37 37 + .values({ 38 38 + did: spindle.did, 43 39 rev: spindle.rev, 40 40 + rkey: spindle.rkey, 44 41 cid: spindle.cid, 45 42 deleted: false, 46 43 47 44 createdAt: new Date(spindleRecord.createdAt), 48 48 - }, 49 49 - setWhere: lt(tangledSpindle.rev, spindle.rev) 50 50 - }) 45 45 + }) 46 46 + .onConflictDoUpdate({ 47 47 + target: [tangledSpindle.did, tangledSpindle.rkey], 48 48 + set: { 49 49 + rev: spindle.rev, 50 50 + cid: spindle.cid, 51 51 + deleted: false, 52 52 + 53 53 + createdAt: new Date(spindleRecord.createdAt), 54 54 + }, 55 55 + setWhere: lt(tangledSpindle.rev, spindle.rev), 56 56 + }); 51 57 } 52 52 - } 58 58 + };

+36 -30

api/src/ingest/spindleMember.ts

reviewed

··· 7 7 export const ingestSpindleMember: CollectionHandler = async (spindleMembers) => { 8 8 for (const spindleMember of spindleMembers) { 9 9 if (spindleMember.action === "delete") { 10 10 - await db.insert(tangledSpindleMember).values({ 11 11 - did: spindleMember.did, 12 12 - rev: spindleMember.rev, 13 13 - rkey: spindleMember.rkey, 14 14 - cid: null, 15 15 - deleted: true, 16 16 - }).onConflictDoUpdate({ 17 17 - target: [tangledSpindleMember.did, tangledSpindleMember.rkey], 18 18 - set: { 10 10 + await db 11 11 + .insert(tangledSpindleMember) 12 12 + .values({ 13 13 + did: spindleMember.did, 19 14 rev: spindleMember.rev, 15 15 + rkey: spindleMember.rkey, 20 16 cid: null, 21 21 - deleted: true 22 22 - }, 23 23 - setWhere: lt(tangledSpindleMember.rev, spindleMember.rev) 24 24 - }); 17 17 + deleted: true, 18 18 + }) 19 19 + .onConflictDoUpdate({ 20 20 + target: [tangledSpindleMember.did, tangledSpindleMember.rkey], 21 21 + set: { 22 22 + rev: spindleMember.rev, 23 23 + cid: null, 24 24 + deleted: true, 25 25 + }, 26 26 + setWhere: lt(tangledSpindleMember.rev, spindleMember.rev), 27 27 + }); 25 28 continue; 26 29 } 27 30 ··· 29 32 if (!validatedRecord.success) continue; 30 33 const { value: spindleMemberRecord } = validatedRecord; 31 34 32 32 - await db.insert(tangledSpindleMember).values({ 33 33 - did: spindleMember.did, 34 34 - rev: spindleMember.rev, 35 35 - rkey: spindleMember.rkey, 36 36 - cid: spindleMember.cid, 37 37 - deleted: false, 38 38 - 39 39 - subject: spindleMemberRecord.subject, 40 40 - instance: spindleMemberRecord.instance, 41 41 - createdAt: new Date(spindleMemberRecord.createdAt), 42 42 - }).onConflictDoUpdate({ 43 43 - target: [tangledSpindleMember.did, tangledSpindleMember.rkey], 44 44 - set: { 35 35 + await db 36 36 + .insert(tangledSpindleMember) 37 37 + .values({ 38 38 + did: spindleMember.did, 45 39 rev: spindleMember.rev, 40 40 + rkey: spindleMember.rkey, 46 41 cid: spindleMember.cid, 47 42 deleted: false, 48 43 49 44 subject: spindleMemberRecord.subject, 50 45 instance: spindleMemberRecord.instance, 51 46 createdAt: new Date(spindleMemberRecord.createdAt), 52 52 - }, 53 53 - setWhere: lt(tangledSpindleMember.rev, spindleMember.rev) 54 54 - }) 47 47 + }) 48 48 + .onConflictDoUpdate({ 49 49 + target: [tangledSpindleMember.did, tangledSpindleMember.rkey], 50 50 + set: { 51 51 + rev: spindleMember.rev, 52 52 + cid: spindleMember.cid, 53 53 + deleted: false, 54 54 + 55 55 + subject: spindleMemberRecord.subject, 56 56 + instance: spindleMemberRecord.instance, 57 57 + createdAt: new Date(spindleMemberRecord.createdAt), 58 58 + }, 59 59 + setWhere: lt(tangledSpindleMember.rev, spindleMember.rev), 60 60 + }); 55 61 } 56 56 - } 62 62 + };

+36 -30

api/src/ingest/star.ts

reviewed

··· 7 7 export const ingestStar: CollectionHandler = async (stars) => { 8 8 for (const star of stars) { 9 9 if (star.action === "delete") { 10 10 - await db.insert(tangledStar).values({ 11 11 - did: star.did, 12 12 - rev: star.rev, 13 13 - rkey: star.rkey, 14 14 - cid: null, 15 15 - deleted: true, 16 16 - }).onConflictDoUpdate({ 17 17 - target: [tangledStar.did, tangledStar.rkey], 18 18 - set: { 10 10 + await db 11 11 + .insert(tangledStar) 12 12 + .values({ 13 13 + did: star.did, 19 14 rev: star.rev, 15 15 + rkey: star.rkey, 20 16 cid: null, 21 21 - deleted: true 22 22 - }, 23 23 - setWhere: lt(tangledStar.rev, star.rev) 24 24 - }); 17 17 + deleted: true, 18 18 + }) 19 19 + .onConflictDoUpdate({ 20 20 + target: [tangledStar.did, tangledStar.rkey], 21 21 + set: { 22 22 + rev: star.rev, 23 23 + cid: null, 24 24 + deleted: true, 25 25 + }, 26 26 + setWhere: lt(tangledStar.rev, star.rev), 27 27 + }); 25 28 continue; 26 29 } 27 30 ··· 29 32 if (!validatedRecord.success) continue; 30 33 const { value: starRecord } = validatedRecord; 31 34 32 32 - await db.insert(tangledStar).values({ 33 33 - did: star.did, 34 34 - rev: star.rev, 35 35 - rkey: star.rkey, 36 36 - cid: star.cid, 37 37 - deleted: false, 38 38 - 39 39 - subject: starRecord.subject, 40 40 - subjectDid: starRecord.subjectDid, 41 41 - createdAt: new Date(starRecord.createdAt), 42 42 - }).onConflictDoUpdate({ 43 43 - target: [tangledStar.did, tangledStar.rkey], 44 44 - set: { 35 35 + await db 36 36 + .insert(tangledStar) 37 37 + .values({ 38 38 + did: star.did, 45 39 rev: star.rev, 40 40 + rkey: star.rkey, 46 41 cid: star.cid, 47 42 deleted: false, 48 43 49 44 subject: starRecord.subject, 50 45 subjectDid: starRecord.subjectDid, 51 46 createdAt: new Date(starRecord.createdAt), 52 52 - }, 53 53 - setWhere: lt(tangledStar.rev, star.rev) 54 54 - }) 47 47 + }) 48 48 + .onConflictDoUpdate({ 49 49 + target: [tangledStar.did, tangledStar.rkey], 50 50 + set: { 51 51 + rev: star.rev, 52 52 + cid: star.cid, 53 53 + deleted: false, 54 54 + 55 55 + subject: starRecord.subject, 56 56 + subjectDid: starRecord.subjectDid, 57 57 + createdAt: new Date(starRecord.createdAt), 58 58 + }, 59 59 + setWhere: lt(tangledStar.rev, star.rev), 60 60 + }); 55 61 } 56 56 - } 62 62 + };

+37 -31

api/src/ingest/string.ts

reviewed

··· 7 7 export const ingestString: CollectionHandler = async (strings) => { 8 8 for (const string of strings) { 9 9 if (string.action === "delete") { 10 10 - await db.insert(tangledString).values({ 11 11 - did: string.did, 12 12 - rev: string.rev, 13 13 - rkey: string.rkey, 14 14 - cid: null, 15 15 - deleted: true, 16 16 - }).onConflictDoUpdate({ 17 17 - target: [tangledString.did, tangledString.rkey], 18 18 - set: { 10 10 + await db 11 11 + .insert(tangledString) 12 12 + .values({ 13 13 + did: string.did, 19 14 rev: string.rev, 15 15 + rkey: string.rkey, 20 16 cid: null, 21 21 - deleted: true 22 22 - }, 23 23 - setWhere: lt(tangledString.rev, string.rev) 24 24 - }); 17 17 + deleted: true, 18 18 + }) 19 19 + .onConflictDoUpdate({ 20 20 + target: [tangledString.did, tangledString.rkey], 21 21 + set: { 22 22 + rev: string.rev, 23 23 + cid: null, 24 24 + deleted: true, 25 25 + }, 26 26 + setWhere: lt(tangledString.rev, string.rev), 27 27 + }); 25 28 continue; 26 29 } 27 30 ··· 29 32 if (!validatedRecord.success) continue; 30 33 const { value: stringRecord } = validatedRecord; 31 34 32 32 - await db.insert(tangledString).values({ 33 33 - did: string.did, 34 34 - rev: string.rev, 35 35 - rkey: string.rkey, 36 36 - cid: string.cid, 37 37 - deleted: false, 38 38 - 39 39 - filename: stringRecord.filename, 40 40 - description: stringRecord.description, 41 41 - createdAt: new Date(stringRecord.createdAt), 42 42 - contents: stringRecord.contents, 43 43 - }).onConflictDoUpdate({ 44 44 - target: [tangledString.did, tangledString.rkey], 45 45 - set: { 35 35 + await db 36 36 + .insert(tangledString) 37 37 + .values({ 38 38 + did: string.did, 46 39 rev: string.rev, 40 40 + rkey: string.rkey, 47 41 cid: string.cid, 48 42 deleted: false, 49 43 ··· 51 45 description: stringRecord.description, 52 46 createdAt: new Date(stringRecord.createdAt), 53 47 contents: stringRecord.contents, 54 54 - }, 55 55 - setWhere: lt(tangledString.rev, string.rev) 56 56 - }) 48 48 + }) 49 49 + .onConflictDoUpdate({ 50 50 + target: [tangledString.did, tangledString.rkey], 51 51 + set: { 52 52 + rev: string.rev, 53 53 + cid: string.cid, 54 54 + deleted: false, 55 55 + 56 56 + filename: stringRecord.filename, 57 57 + description: stringRecord.description, 58 58 + createdAt: new Date(stringRecord.createdAt), 59 59 + contents: stringRecord.contents, 60 60 + }, 61 61 + setWhere: lt(tangledString.rev, string.rev), 62 62 + }); 57 63 } 58 58 - } 64 64 + };

+68 -59

api/src/ingest/tap.ts

reviewed

··· 1 1 - import { Tap, type RecordEvent, type TapHandler } from '@atproto/tap' 2 2 - import { jsonToLex, type JsonValue, lexToJson } from '@atproto/lex'; 3 3 - import { db } from '../db/index.ts'; 4 4 - import { rawRecords } from '../db/tables/raw_records.ts'; 5 5 - import { TAP_URL } from '../lib/constants.ts'; 6 6 - import { ingestProfile } from './profile.ts'; 7 7 - import { ingestRepo } from './repo.ts'; 8 8 - import { ingestReaction } from './reaction.ts'; 9 9 - import { ingestStar } from './star.ts'; 10 10 - import { ingestRefUpdate } from './refUpdate.ts'; 11 11 - import { ingestFollow } from './follow.ts'; 12 12 - import { ingestVouch } from './vouch.ts'; 13 13 - import { ingestIssueComment } from './issueComment.ts'; 14 14 - import { ingestIssue } from './issue.ts'; 15 15 - import { ingestIssueState } from './issueState.ts'; 16 16 - import { ingestKnot } from './knot.ts'; 17 17 - import { ingestKnotMember } from './knotMember.ts'; 18 18 - import { ingestLabelDefinition } from './labelDefinition.ts'; 19 19 - import { ingestLabelOp } from './labelOp.ts'; 20 20 - import { ingestPipeline } from './pipeline.ts'; 21 21 - import { ingestPipelineStatus } from './pipelineStatus.ts'; 22 22 - import { ingestPublicKey } from './publicKey.ts'; 23 23 - import { ingestPullComment } from './pullComment.ts'; 24 24 - import { ingestPull } from './pull.ts'; 25 25 - import { ingestPullStatus } from './pullStatus.ts'; 26 26 - import { ingestArtifact } from './artifact.ts'; 27 27 - import { ingestCollaborator } from './collaborator.ts'; 28 28 - import { ingestSpindleMember } from './spindleMember.ts'; 29 29 - import { ingestSpindle } from './spindle.ts'; 30 30 - import { ingestString } from './string.ts'; 1 1 + import { Tap, type RecordEvent, type TapHandler } from "@atproto/tap"; 2 2 + import { jsonToLex, type JsonValue, lexToJson } from "@atproto/lex"; 3 3 + import { db } from "../db/index.ts"; 4 4 + import { rawRecords } from "../db/tables/raw_records.ts"; 5 5 + import { TAP_URL } from "../lib/constants.ts"; 6 6 + import { ingestProfile } from "./profile.ts"; 7 7 + import { ingestRepo } from "./repo.ts"; 8 8 + import { ingestReaction } from "./reaction.ts"; 9 9 + import { ingestStar } from "./star.ts"; 10 10 + import { ingestRefUpdate } from "./refUpdate.ts"; 11 11 + import { ingestFollow } from "./follow.ts"; 12 12 + import { ingestVouch } from "./vouch.ts"; 13 13 + import { ingestIssueComment } from "./issueComment.ts"; 14 14 + import { ingestIssue } from "./issue.ts"; 15 15 + import { ingestIssueState } from "./issueState.ts"; 16 16 + import { ingestKnot } from "./knot.ts"; 17 17 + import { ingestKnotMember } from "./knotMember.ts"; 18 18 + import { ingestLabelDefinition } from "./labelDefinition.ts"; 19 19 + import { ingestLabelOp } from "./labelOp.ts"; 20 20 + import { ingestPipeline } from "./pipeline.ts"; 21 21 + import { ingestPipelineStatus } from "./pipelineStatus.ts"; 22 22 + import { ingestPublicKey } from "./publicKey.ts"; 23 23 + import { ingestPullComment } from "./pullComment.ts"; 24 24 + import { ingestPull } from "./pull.ts"; 25 25 + import { ingestPullStatus } from "./pullStatus.ts"; 26 26 + import { ingestArtifact } from "./artifact.ts"; 27 27 + import { ingestCollaborator } from "./collaborator.ts"; 28 28 + import { ingestSpindleMember } from "./spindleMember.ts"; 29 29 + import { ingestSpindle } from "./spindle.ts"; 30 30 + import { ingestString } from "./string.ts"; 31 31 32 32 const tap = new Tap(TAP_URL); 33 33 ··· 38 38 let rowBuffer: [RecordEvent, () => Promise<void>][] = []; 39 39 let flushTimer: ReturnType<typeof setTimeout> | null = null; 40 40 41 41 - type CollectionHandlerArg = { 42 42 - did: `did:${string}:${string}`; 43 43 - rev: string; 44 44 - collection: `${string}.${string}.${string}`; 45 45 - rkey: string; 46 46 - action: "create" | "update"; 47 47 - cid: string; 48 48 - record: JsonValue; 49 49 - } | { 50 50 - did: `did:${string}:${string}`; 51 51 - rev: string; 52 52 - collection: `${string}.${string}.${string}`; 53 53 - rkey: string; 54 54 - action: "delete"; 55 55 - cid: undefined; 56 56 - record: JsonValue; 57 57 - }; 41 41 + type CollectionHandlerArg = 42 42 + | { 43 43 + did: `did:${string}:${string}`; 44 44 + rev: string; 45 45 + collection: `${string}.${string}.${string}`; 46 46 + rkey: string; 47 47 + action: "create" | "update"; 48 48 + cid: string; 49 49 + record: JsonValue; 50 50 + } 51 51 + | { 52 52 + did: `did:${string}:${string}`; 53 53 + rev: string; 54 54 + collection: `${string}.${string}.${string}`; 55 55 + rkey: string; 56 56 + action: "delete"; 57 57 + cid: undefined; 58 58 + record: JsonValue; 59 59 + }; 58 60 59 61 export type CollectionHandler = (updates: CollectionHandlerArg[]) => Promise<void>; 60 62 ··· 92 94 for (const [collection, records] of Object.entries(splitByCollection)) { 93 95 if (!COLLECTION_HANDLERS[collection] || !records) continue; 94 96 if (log) console.log("Starting syncing", collection); 95 95 - await COLLECTION_HANDLERS[collection](records).catch(console.error) 97 97 + await COLLECTION_HANDLERS[collection](records).catch(console.error); 96 98 if (log) console.log("Finished syncing", collection); 97 99 } 98 100 } ··· 108 110 rkey: evt.rkey, 109 111 action: evt.action, 110 112 cid: evt.cid, 111 111 - record: evt.record ? lexToJson(evt.record) : null 113 113 + record: evt.record ? lexToJson(evt.record) : null, 112 114 })); 113 115 114 114 - const insertedRows = await db.insert(rawRecords).values(mappedBatch).onConflictDoNothing({ target: rawRecords.tap_id }).returning(); 115 115 - const insertedTapIds = new Set(insertedRows.map(row => row.tap_id)); 116 116 + const insertedRows = await db 117 117 + .insert(rawRecords) 118 118 + .values(mappedBatch) 119 119 + .onConflictDoNothing({ target: rawRecords.tap_id }) 120 120 + .returning(); 121 121 + const insertedTapIds = new Set(insertedRows.map((row) => row.tap_id)); 116 122 console.log(`Inserted ${insertedTapIds.size} rows.`); 117 123 118 124 const insertedRecords = mappedBatch.filter(({ tap_id }) => insertedTapIds.has(tap_id)); ··· 120 126 // kinda sus, but trust bro 121 127 syncLevelTwoTables(insertedRecords as CollectionHandlerArg[]); 122 128 123 123 - await Promise.all(batch.map(([_, ack]) => ack())) 129 129 + await Promise.all(batch.map(([_, ack]) => ack())); 124 130 } catch (err) { 125 131 if (batch.length === 1) { 126 132 console.error("Mb chat, it's over", err); ··· 134 140 } 135 141 136 142 async function flush() { 137 137 - if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; } 143 143 + if (flushTimer) { 144 144 + clearTimeout(flushTimer); 145 145 + flushTimer = null; 146 146 + } 138 147 if (rowBuffer.length === 0) return; 139 148 const batch = rowBuffer; 140 149 rowBuffer = []; ··· 152 161 (evt.action === "create" || evt.action === "update") && 153 162 (evt.cid == null || evt.record == null) 154 163 ) { 155 155 - console.log("slop spotted, acking and dropping") 164 164 + console.log("slop spotted, acking and dropping"); 156 165 await opts.ack(); 157 166 return; 158 167 } ··· 165 174 }, 166 175 167 176 onError: (err) => console.error("Tap Error:", err), 168 168 - } 177 177 + }; 169 178 170 170 - const channel = tap.channel(indexer) 171 171 - channel.start() 179 179 + const channel = tap.channel(indexer); 180 180 + channel.start(); 172 181 console.log("Started Tap Importer..."); 173 182 174 183 (async () => { ··· 176 185 177 186 const relexed = fullIngest.map(({ record, ...fields }) => ({ 178 187 ...fields, 179 179 - record: jsonToLex(record as JsonValue) 180 180 - })) 188 188 + record: jsonToLex(record as JsonValue), 189 189 + })); 181 190 182 191 // kinda sus, but trust bro 183 192 await syncLevelTwoTables(relexed as CollectionHandlerArg[], true);

+36 -30

api/src/ingest/vouch.ts

reviewed

··· 7 7 export const ingestVouch: CollectionHandler = async (vouches) => { 8 8 for (const vouch of vouches) { 9 9 if (vouch.action === "delete") { 10 10 - await db.insert(tangledVouch).values({ 11 11 - did: vouch.did, 12 12 - rev: vouch.rev, 13 13 - rkey: vouch.rkey, 14 14 - cid: null, 15 15 - deleted: true, 16 16 - }).onConflictDoUpdate({ 17 17 - target: [tangledVouch.did, tangledVouch.rkey], 18 18 - set: { 10 10 + await db 11 11 + .insert(tangledVouch) 12 12 + .values({ 13 13 + did: vouch.did, 19 14 rev: vouch.rev, 15 15 + rkey: vouch.rkey, 20 16 cid: null, 21 21 - deleted: true 22 22 - }, 23 23 - setWhere: lt(tangledVouch.rev, vouch.rev) 24 24 - }); 17 17 + deleted: true, 18 18 + }) 19 19 + .onConflictDoUpdate({ 20 20 + target: [tangledVouch.did, tangledVouch.rkey], 21 21 + set: { 22 22 + rev: vouch.rev, 23 23 + cid: null, 24 24 + deleted: true, 25 25 + }, 26 26 + setWhere: lt(tangledVouch.rev, vouch.rev), 27 27 + }); 25 28 continue; 26 29 } 27 30 ··· 29 32 if (!validatedRecord.success) continue; 30 33 const { value: vouchRecord } = validatedRecord; 31 34 32 32 - await db.insert(tangledVouch).values({ 33 33 - did: vouch.did, 34 34 - rev: vouch.rev, 35 35 - rkey: vouch.rkey, 36 36 - cid: vouch.cid, 37 37 - deleted: false, 38 38 - 39 39 - kind: vouchRecord.kind, 40 40 - reason: vouchRecord.reason, 41 41 - createdAt: new Date(vouchRecord.createdAt), 42 42 - }).onConflictDoUpdate({ 43 43 - target: [tangledVouch.did, tangledVouch.rkey], 44 44 - set: { 35 35 + await db 36 36 + .insert(tangledVouch) 37 37 + .values({ 38 38 + did: vouch.did, 45 39 rev: vouch.rev, 40 40 + rkey: vouch.rkey, 46 41 cid: vouch.cid, 47 42 deleted: false, 48 43 49 44 kind: vouchRecord.kind, 50 45 reason: vouchRecord.reason, 51 46 createdAt: new Date(vouchRecord.createdAt), 52 52 - }, 53 53 - setWhere: lt(tangledVouch.rev, vouch.rev) 54 54 - }) 47 47 + }) 48 48 + .onConflictDoUpdate({ 49 49 + target: [tangledVouch.did, tangledVouch.rkey], 50 50 + set: { 51 51 + rev: vouch.rev, 52 52 + cid: vouch.cid, 53 53 + deleted: false, 54 54 + 55 55 + kind: vouchRecord.kind, 56 56 + reason: vouchRecord.reason, 57 57 + createdAt: new Date(vouchRecord.createdAt), 58 58 + }, 59 59 + setWhere: lt(tangledVouch.rev, vouch.rev), 60 60 + }); 55 61 } 56 56 - } 62 62 + };

+1 -1

api/src/lexicons/sh.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * as tangled from './sh/tangled.ts' 5 5 + export * as tangled from "./sh/tangled.ts";

+13 -13

api/src/lexicons/sh/tangled.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * as actor from './tangled/actor.ts' 6 6 - export * as feed from './tangled/feed.ts' 7 7 - export * as git from './tangled/git.ts' 8 8 - export * as graph from './tangled/graph.ts' 9 9 - export * as repo from './tangled/repo.ts' 10 10 - export * as knot from './tangled/knot.ts' 11 11 - export * as label from './tangled/label.ts' 12 12 - export * as owner from './tangled/owner.ts' 13 13 - export * as pipeline from './tangled/pipeline.ts' 14 14 - export * as publicKey from './tangled/publicKey.ts' 15 15 - export * as spindle from './tangled/spindle.ts' 16 16 - export * as string from './tangled/string.ts' 17 17 - export * as sync from './tangled/sync.ts' 5 5 + export * as actor from "./tangled/actor.ts"; 6 6 + export * as feed from "./tangled/feed.ts"; 7 7 + export * as git from "./tangled/git.ts"; 8 8 + export * as graph from "./tangled/graph.ts"; 9 9 + export * as repo from "./tangled/repo.ts"; 10 10 + export * as knot from "./tangled/knot.ts"; 11 11 + export * as label from "./tangled/label.ts"; 12 12 + export * as owner from "./tangled/owner.ts"; 13 13 + export * as pipeline from "./tangled/pipeline.ts"; 14 14 + export * as publicKey from "./tangled/publicKey.ts"; 15 15 + export * as spindle from "./tangled/spindle.ts"; 16 16 + export * as string from "./tangled/string.ts"; 17 17 + export * as sync from "./tangled/sync.ts";

+1 -1

api/src/lexicons/sh/tangled/actor.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * as profile from './actor/profile.ts' 5 5 + export * as profile from "./actor/profile.ts";

+39 -45

api/src/lexicons/sh/tangled/actor/profile.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.actor.profile' 7 7 + const $nsid = "sh.tangled.actor.profile"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 /** A declaration of a Tangled account profile. */ 12 12 type Main = { 13 13 - $type: 'sh.tangled.actor.profile' 13 13 + $type: "sh.tangled.actor.profile"; 14 14 15 15 /** 16 16 * Small image to be displayed next to posts from account. AKA, 'profile picture' 17 17 */ 18 18 - avatar?: l.BlobRef 18 18 + avatar?: l.BlobRef; 19 19 20 20 /** 21 21 * Free-form profile description text. 22 22 */ 23 23 - description?: string 24 24 - links?: l.UriString[] 23 23 + description?: string; 24 24 + links?: l.UriString[]; 25 25 stats?: ( 26 26 - | 'merged-pull-request-count' 27 27 - | 'closed-pull-request-count' 28 28 - | 'open-pull-request-count' 29 29 - | 'open-issue-count' 30 30 - | 'closed-issue-count' 31 31 - | 'repository-count' 32 32 - | 'star-count' 33 33 - )[] 26 26 + | "merged-pull-request-count" 27 27 + | "closed-pull-request-count" 28 28 + | "open-pull-request-count" 29 29 + | "open-issue-count" 30 30 + | "closed-issue-count" 31 31 + | "repository-count" 32 32 + | "star-count" 33 33 + )[]; 34 34 35 35 /** 36 36 * Include link to this account on Bluesky. 37 37 */ 38 38 - bluesky: boolean 38 38 + bluesky: boolean; 39 39 40 40 /** 41 41 * Free-form location text. 42 42 */ 43 43 - location?: string 43 43 + location?: string; 44 44 45 45 /** 46 46 * Pinned repositories. Values are repo DIDs for repos that have them, or AT-URIs for legacy repos. 47 47 */ 48 48 - pinnedRepositories?: string[] 48 48 + pinnedRepositories?: string[]; 49 49 50 50 /** 51 51 * Preferred gender pronouns. 52 52 */ 53 53 - pronouns?: string 53 53 + pronouns?: string; 54 54 55 55 /** 56 56 * A handle the user prefers to be displayed as. 57 57 */ 58 58 - preferredHandle?: l.HandleString 59 59 - } 58 58 + preferredHandle?: l.HandleString; 59 59 + }; 60 60 61 61 - export type { Main } 61 61 + export type { Main }; 62 62 63 63 /** A declaration of a Tangled account profile. */ 64 64 - const main = l.record<'literal:self', Main>( 65 65 - 'literal:self', 64 64 + const main = l.record<"literal:self", Main>( 65 65 + "literal:self", 66 66 $nsid, 67 67 l.object({ 68 68 - avatar: l.optional( 69 69 - l.blob({ accept: ['image/png', 'image/jpeg'], maxSize: 1000000 }), 70 70 - ), 68 68 + avatar: l.optional(l.blob({ accept: ["image/png", "image/jpeg"], maxSize: 1000000 })), 71 69 description: l.optional(l.string({ maxGraphemes: 256, maxLength: 2560 })), 72 72 - links: l.optional( 73 73 - l.array(l.string({ format: 'uri' }), { minLength: 0, maxLength: 5 }), 74 74 - ), 70 70 + links: l.optional(l.array(l.string({ format: "uri" }), { minLength: 0, maxLength: 5 })), 75 71 stats: l.optional( 76 72 l.array( 77 73 l.enum([ 78 78 - 'merged-pull-request-count', 79 79 - 'closed-pull-request-count', 80 80 - 'open-pull-request-count', 81 81 - 'open-issue-count', 82 82 - 'closed-issue-count', 83 83 - 'repository-count', 84 84 - 'star-count', 74 74 + "merged-pull-request-count", 75 75 + "closed-pull-request-count", 76 76 + "open-pull-request-count", 77 77 + "open-issue-count", 78 78 + "closed-issue-count", 79 79 + "repository-count", 80 80 + "star-count", 85 81 ]), 86 82 { minLength: 0, maxLength: 2 }, 87 83 ), 88 84 ), 89 85 bluesky: l.boolean(), 90 86 location: l.optional(l.string({ maxGraphemes: 40, maxLength: 400 })), 91 91 - pinnedRepositories: l.optional( 92 92 - l.array(l.string(), { minLength: 0, maxLength: 6 }), 93 93 - ), 87 87 + pinnedRepositories: l.optional(l.array(l.string(), { minLength: 0, maxLength: 6 })), 94 88 pronouns: l.optional(l.string({ maxLength: 40 })), 95 95 - preferredHandle: l.optional(l.string({ format: 'handle', maxLength: 253 })), 89 89 + preferredHandle: l.optional(l.string({ format: "handle", maxLength: 253 })), 96 90 }), 97 97 - ) 91 91 + ); 98 92 99 99 - export { main } 93 93 + export { main }; 100 94 101 95 export const $isTypeOf = /*#__PURE__*/ main.isTypeOf.bind(main), 102 96 $build = /*#__PURE__*/ main.build.bind(main), 103 103 - $type = /*#__PURE__*/ main.$type 97 97 + $type = /*#__PURE__*/ main.$type; 104 98 export const $assert = /*#__PURE__*/ main.assert.bind(main), 105 99 $check = /*#__PURE__*/ main.check.bind(main), 106 100 $cast = /*#__PURE__*/ main.cast.bind(main), ··· 109 103 $parse = /*#__PURE__*/ main.parse.bind(main), 110 104 $safeParse = /*#__PURE__*/ main.safeParse.bind(main), 111 105 $validate = /*#__PURE__*/ main.validate.bind(main), 112 112 - $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main) 106 106 + $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main);

+2 -2

api/src/lexicons/sh/tangled/actor/profile.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './profile.defs.ts' 6 6 - export * as $defs from './profile.defs.ts' 5 5 + export * from "./profile.defs.ts"; 6 6 + export * as $defs from "./profile.defs.ts";

+2 -2

api/src/lexicons/sh/tangled/feed.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * as reaction from './feed/reaction.ts' 6 6 - export * as star from './feed/star.ts' 5 5 + export * as reaction from "./feed/reaction.ts"; 6 6 + export * as star from "./feed/star.ts";

+18 -18

api/src/lexicons/sh/tangled/feed/reaction.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.feed.reaction' 7 7 + const $nsid = "sh.tangled.feed.reaction"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 type Main = { 12 12 - $type: 'sh.tangled.feed.reaction' 13 13 - subject: l.AtUriString 14 14 - reaction: '👍' | '👎' | '😆' | '🎉' | '🫤' | '❤️' | '🚀' | '👀' 15 15 - createdAt: l.DatetimeString 16 16 - } 12 12 + $type: "sh.tangled.feed.reaction"; 13 13 + subject: l.AtUriString; 14 14 + reaction: "👍" | "👎" | "😆" | "🎉" | "🫤" | "❤️" | "🚀" | "👀"; 15 15 + createdAt: l.DatetimeString; 16 16 + }; 17 17 18 18 - export type { Main } 18 18 + export type { Main }; 19 19 20 20 - const main = l.record<'tid', Main>( 21 21 - 'tid', 20 20 + const main = l.record<"tid", Main>( 21 21 + "tid", 22 22 $nsid, 23 23 l.object({ 24 24 - subject: l.string({ format: 'at-uri' }), 25 25 - reaction: l.enum(['👍', '👎', '😆', '🎉', '🫤', '❤️', '🚀', '👀']), 26 26 - createdAt: l.string({ format: 'datetime' }), 24 24 + subject: l.string({ format: "at-uri" }), 25 25 + reaction: l.enum(["👍", "👎", "😆", "🎉", "🫤", "❤️", "🚀", "👀"]), 26 26 + createdAt: l.string({ format: "datetime" }), 27 27 }), 28 28 - ) 28 28 + ); 29 29 30 30 - export { main } 30 30 + export { main }; 31 31 32 32 export const $isTypeOf = /*#__PURE__*/ main.isTypeOf.bind(main), 33 33 $build = /*#__PURE__*/ main.build.bind(main), 34 34 - $type = /*#__PURE__*/ main.$type 34 34 + $type = /*#__PURE__*/ main.$type; 35 35 export const $assert = /*#__PURE__*/ main.assert.bind(main), 36 36 $check = /*#__PURE__*/ main.check.bind(main), 37 37 $cast = /*#__PURE__*/ main.cast.bind(main), ··· 40 40 $parse = /*#__PURE__*/ main.parse.bind(main), 41 41 $safeParse = /*#__PURE__*/ main.safeParse.bind(main), 42 42 $validate = /*#__PURE__*/ main.validate.bind(main), 43 43 - $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main) 43 43 + $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main);

+2 -2

api/src/lexicons/sh/tangled/feed/reaction.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './reaction.defs.ts' 6 6 - export * as $defs from './reaction.defs.ts' 5 5 + export * from "./reaction.defs.ts"; 6 6 + export * as $defs from "./reaction.defs.ts";

+18 -18

api/src/lexicons/sh/tangled/feed/star.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.feed.star' 7 7 + const $nsid = "sh.tangled.feed.star"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 type Main = { 12 12 - $type: 'sh.tangled.feed.star' 13 13 - subject?: l.AtUriString 14 14 - subjectDid?: l.DidString 15 15 - createdAt: l.DatetimeString 16 16 - } 12 12 + $type: "sh.tangled.feed.star"; 13 13 + subject?: l.AtUriString; 14 14 + subjectDid?: l.DidString; 15 15 + createdAt: l.DatetimeString; 16 16 + }; 17 17 18 18 - export type { Main } 18 18 + export type { Main }; 19 19 20 20 - const main = l.record<'tid', Main>( 21 21 - 'tid', 20 20 + const main = l.record<"tid", Main>( 21 21 + "tid", 22 22 $nsid, 23 23 l.object({ 24 24 - subject: l.optional(l.string({ format: 'at-uri' })), 25 25 - subjectDid: l.optional(l.string({ format: 'did' })), 26 26 - createdAt: l.string({ format: 'datetime' }), 24 24 + subject: l.optional(l.string({ format: "at-uri" })), 25 25 + subjectDid: l.optional(l.string({ format: "did" })), 26 26 + createdAt: l.string({ format: "datetime" }), 27 27 }), 28 28 - ) 28 28 + ); 29 29 30 30 - export { main } 30 30 + export { main }; 31 31 32 32 export const $isTypeOf = /*#__PURE__*/ main.isTypeOf.bind(main), 33 33 $build = /*#__PURE__*/ main.build.bind(main), 34 34 - $type = /*#__PURE__*/ main.$type 34 34 + $type = /*#__PURE__*/ main.$type; 35 35 export const $assert = /*#__PURE__*/ main.assert.bind(main), 36 36 $check = /*#__PURE__*/ main.check.bind(main), 37 37 $cast = /*#__PURE__*/ main.cast.bind(main), ··· 40 40 $parse = /*#__PURE__*/ main.parse.bind(main), 41 41 $safeParse = /*#__PURE__*/ main.safeParse.bind(main), 42 42 $validate = /*#__PURE__*/ main.validate.bind(main), 43 43 - $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main) 43 43 + $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main);

+2 -2

api/src/lexicons/sh/tangled/feed/star.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './star.defs.ts' 6 6 - export * as $defs from './star.defs.ts' 5 5 + export * from "./star.defs.ts"; 6 6 + export * as $defs from "./star.defs.ts";

+2 -2

api/src/lexicons/sh/tangled/git.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * as refUpdate from './git/refUpdate.ts' 6 6 - export * as temp from './git/temp.ts' 5 5 + export * as refUpdate from "./git/refUpdate.ts"; 6 6 + export * as temp from "./git/temp.ts";

+66 -76

api/src/lexicons/sh/tangled/git/refUpdate.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.git.refUpdate' 7 7 + const $nsid = "sh.tangled.git.refUpdate"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 /** An update to a git repository, emitted by knots. */ 12 12 type Main = { 13 13 - $type: 'sh.tangled.git.refUpdate' 13 13 + $type: "sh.tangled.git.refUpdate"; 14 14 15 15 /** 16 16 * Ref being updated 17 17 */ 18 18 - ref: string 18 18 + ref: string; 19 19 20 20 /** 21 21 * did of the user that pushed this ref 22 22 */ 23 23 - committerDid: l.DidString 23 23 + committerDid: l.DidString; 24 24 25 25 /** 26 26 * did of the owner of the repo 27 27 */ 28 28 - ownerDid?: l.DidString 28 28 + ownerDid?: l.DidString; 29 29 30 30 /** 31 31 * DID of the repo itself 32 32 */ 33 33 - repoDid?: l.DidString 33 33 + repoDid?: l.DidString; 34 34 35 35 /** 36 36 * name of the repo 37 37 */ 38 38 - repoName: string 38 38 + repoName: string; 39 39 40 40 /** 41 41 * old SHA of this ref 42 42 */ 43 43 - oldSha: string 43 43 + oldSha: string; 44 44 45 45 /** 46 46 * new SHA of this ref 47 47 */ 48 48 - newSha: string 49 49 - meta: Meta 50 50 - } 48 48 + newSha: string; 49 49 + meta: Meta; 50 50 + }; 51 51 52 52 - export type { Main } 52 52 + export type { Main }; 53 53 54 54 /** An update to a git repository, emitted by knots. */ 55 55 - const main = l.record<'tid', Main>( 56 56 - 'tid', 55 55 + const main = l.record<"tid", Main>( 56 56 + "tid", 57 57 $nsid, 58 58 l.object({ 59 59 ref: l.string({ maxGraphemes: 256, maxLength: 2560 }), 60 60 - committerDid: l.string({ format: 'did' }), 61 61 - ownerDid: l.optional(l.string({ format: 'did' })), 62 62 - repoDid: l.optional(l.string({ format: 'did' })), 60 60 + committerDid: l.string({ format: "did" }), 61 61 + ownerDid: l.optional(l.string({ format: "did" })), 62 62 + repoDid: l.optional(l.string({ format: "did" })), 63 63 repoName: l.string(), 64 64 oldSha: l.string({ minLength: 40, maxLength: 40 }), 65 65 newSha: l.string({ minLength: 40, maxLength: 40 }), 66 66 meta: l.ref<Meta>((() => meta) as any), 67 67 }), 68 68 - ) 68 68 + ); 69 69 70 70 - export { main } 70 70 + export { main }; 71 71 72 72 export const $isTypeOf = /*#__PURE__*/ main.isTypeOf.bind(main), 73 73 $build = /*#__PURE__*/ main.build.bind(main), 74 74 - $type = /*#__PURE__*/ main.$type 74 74 + $type = /*#__PURE__*/ main.$type; 75 75 export const $assert = /*#__PURE__*/ main.assert.bind(main), 76 76 $check = /*#__PURE__*/ main.check.bind(main), 77 77 $cast = /*#__PURE__*/ main.cast.bind(main), ··· 80 80 $parse = /*#__PURE__*/ main.parse.bind(main), 81 81 $safeParse = /*#__PURE__*/ main.safeParse.bind(main), 82 82 $validate = /*#__PURE__*/ main.validate.bind(main), 83 83 - $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main) 83 83 + $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main); 84 84 85 85 type Meta = { 86 86 - $type?: 'sh.tangled.git.refUpdate#meta' 87 87 - isDefaultRef: boolean 88 88 - langBreakdown?: LangBreakdown 89 89 - commitCount: CommitCountBreakdown 90 90 - } 86 86 + $type?: "sh.tangled.git.refUpdate#meta"; 87 87 + isDefaultRef: boolean; 88 88 + langBreakdown?: LangBreakdown; 89 89 + commitCount: CommitCountBreakdown; 90 90 + }; 91 91 92 92 - export type { Meta } 92 92 + export type { Meta }; 93 93 94 94 const meta = l.typedObject<Meta>( 95 95 $nsid, 96 96 - 'meta', 96 96 + "meta", 97 97 l.object({ 98 98 isDefaultRef: l.withDefault(l.boolean(), false), 99 99 - langBreakdown: l.optional( 100 100 - l.ref<LangBreakdown>((() => langBreakdown) as any), 101 101 - ), 102 102 - commitCount: l.ref<CommitCountBreakdown>( 103 103 - (() => commitCountBreakdown) as any, 104 104 - ), 99 99 + langBreakdown: l.optional(l.ref<LangBreakdown>((() => langBreakdown) as any)), 100 100 + commitCount: l.ref<CommitCountBreakdown>((() => commitCountBreakdown) as any), 105 101 }), 106 106 - ) 102 102 + ); 107 103 108 108 - export { meta } 104 104 + export { meta }; 109 105 110 106 type LangBreakdown = { 111 111 - $type?: 'sh.tangled.git.refUpdate#langBreakdown' 112 112 - inputs?: IndividualLanguageSize[] 113 113 - } 107 107 + $type?: "sh.tangled.git.refUpdate#langBreakdown"; 108 108 + inputs?: IndividualLanguageSize[]; 109 109 + }; 114 110 115 115 - export type { LangBreakdown } 111 111 + export type { LangBreakdown }; 116 112 117 113 const langBreakdown = l.typedObject<LangBreakdown>( 118 114 $nsid, 119 119 - 'langBreakdown', 115 115 + "langBreakdown", 120 116 l.object({ 121 117 inputs: l.optional( 122 122 - l.array( 123 123 - l.ref<IndividualLanguageSize>((() => individualLanguageSize) as any), 124 124 - ), 118 118 + l.array(l.ref<IndividualLanguageSize>((() => individualLanguageSize) as any)), 125 119 ), 126 120 }), 127 127 - ) 121 121 + ); 128 122 129 129 - export { langBreakdown } 123 123 + export { langBreakdown }; 130 124 131 125 type IndividualLanguageSize = { 132 132 - $type?: 'sh.tangled.git.refUpdate#individualLanguageSize' 133 133 - lang: string 134 134 - size: number 135 135 - } 126 126 + $type?: "sh.tangled.git.refUpdate#individualLanguageSize"; 127 127 + lang: string; 128 128 + size: number; 129 129 + }; 136 130 137 137 - export type { IndividualLanguageSize } 131 131 + export type { IndividualLanguageSize }; 138 132 139 133 const individualLanguageSize = l.typedObject<IndividualLanguageSize>( 140 134 $nsid, 141 141 - 'individualLanguageSize', 135 135 + "individualLanguageSize", 142 136 l.object({ lang: l.string(), size: l.integer() }), 143 143 - ) 137 137 + ); 144 138 145 145 - export { individualLanguageSize } 139 139 + export { individualLanguageSize }; 146 140 147 141 type CommitCountBreakdown = { 148 148 - $type?: 'sh.tangled.git.refUpdate#commitCountBreakdown' 149 149 - byEmail?: IndividualEmailCommitCount[] 150 150 - } 142 142 + $type?: "sh.tangled.git.refUpdate#commitCountBreakdown"; 143 143 + byEmail?: IndividualEmailCommitCount[]; 144 144 + }; 151 145 152 152 - export type { CommitCountBreakdown } 146 146 + export type { CommitCountBreakdown }; 153 147 154 148 const commitCountBreakdown = l.typedObject<CommitCountBreakdown>( 155 149 $nsid, 156 156 - 'commitCountBreakdown', 150 150 + "commitCountBreakdown", 157 151 l.object({ 158 152 byEmail: l.optional( 159 159 - l.array( 160 160 - l.ref<IndividualEmailCommitCount>( 161 161 - (() => individualEmailCommitCount) as any, 162 162 - ), 163 163 - ), 153 153 + l.array(l.ref<IndividualEmailCommitCount>((() => individualEmailCommitCount) as any)), 164 154 ), 165 155 }), 166 166 - ) 156 156 + ); 167 157 168 168 - export { commitCountBreakdown } 158 158 + export { commitCountBreakdown }; 169 159 170 160 type IndividualEmailCommitCount = { 171 171 - $type?: 'sh.tangled.git.refUpdate#individualEmailCommitCount' 172 172 - email: string 173 173 - count: number 174 174 - } 161 161 + $type?: "sh.tangled.git.refUpdate#individualEmailCommitCount"; 162 162 + email: string; 163 163 + count: number; 164 164 + }; 175 165 176 176 - export type { IndividualEmailCommitCount } 166 166 + export type { IndividualEmailCommitCount }; 177 167 178 168 const individualEmailCommitCount = l.typedObject<IndividualEmailCommitCount>( 179 169 $nsid, 180 180 - 'individualEmailCommitCount', 170 170 + "individualEmailCommitCount", 181 171 l.object({ email: l.string(), count: l.integer() }), 182 182 - ) 172 172 + ); 183 173 184 184 - export { individualEmailCommitCount } 174 174 + export { individualEmailCommitCount };

+2 -2

api/src/lexicons/sh/tangled/git/refUpdate.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './refUpdate.defs.ts' 6 6 - export * as $defs from './refUpdate.defs.ts' 5 5 + export * from "./refUpdate.defs.ts"; 6 6 + export * as $defs from "./refUpdate.defs.ts";

+15 -15

api/src/lexicons/sh/tangled/git/temp.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * as analyzeMerge from './temp/analyzeMerge.ts' 6 6 - export * as defs from './temp/defs.ts' 7 7 - export * as getArchive from './temp/getArchive.ts' 8 8 - export * as getBlob from './temp/getBlob.ts' 9 9 - export * as getBranch from './temp/getBranch.ts' 10 10 - export * as getCommit from './temp/getCommit.ts' 11 11 - export * as getDiff from './temp/getDiff.ts' 12 12 - export * as getEntity from './temp/getEntity.ts' 13 13 - export * as getHead from './temp/getHead.ts' 14 14 - export * as getTag from './temp/getTag.ts' 15 15 - export * as getTree from './temp/getTree.ts' 16 16 - export * as listBranches from './temp/listBranches.ts' 17 17 - export * as listCommits from './temp/listCommits.ts' 18 18 - export * as listLanguages from './temp/listLanguages.ts' 19 19 - export * as listTags from './temp/listTags.ts' 5 5 + export * as analyzeMerge from "./temp/analyzeMerge.ts"; 6 6 + export * as defs from "./temp/defs.ts"; 7 7 + export * as getArchive from "./temp/getArchive.ts"; 8 8 + export * as getBlob from "./temp/getBlob.ts"; 9 9 + export * as getBranch from "./temp/getBranch.ts"; 10 10 + export * as getCommit from "./temp/getCommit.ts"; 11 11 + export * as getDiff from "./temp/getDiff.ts"; 12 12 + export * as getEntity from "./temp/getEntity.ts"; 13 13 + export * as getHead from "./temp/getHead.ts"; 14 14 + export * as getTag from "./temp/getTag.ts"; 15 15 + export * as getTree from "./temp/getTree.ts"; 16 16 + export * as listBranches from "./temp/listBranches.ts"; 17 17 + export * as listCommits from "./temp/listCommits.ts"; 18 18 + export * as listLanguages from "./temp/listLanguages.ts"; 19 19 + export * as listTags from "./temp/listTags.ts";

+19 -24

api/src/lexicons/sh/tangled/git/temp/analyzeMerge.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.git.temp.analyzeMerge' 7 7 + const $nsid = "sh.tangled.git.temp.analyzeMerge"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 /** Check if a merge is possible between two branches */ 12 12 const main = l.query( 13 13 $nsid, 14 14 l.params({ 15 15 - repo: l.string({ format: 'at-uri' }), 15 15 + repo: l.string({ format: "at-uri" }), 16 16 patch: l.string(), 17 17 branch: l.string(), 18 18 }), 19 19 l.jsonPayload({ 20 20 is_conflicted: l.boolean(), 21 21 - conflicts: l.optional( 22 22 - l.array(l.ref<ConflictInfo>((() => conflictInfo) as any)), 23 23 - ), 21 21 + conflicts: l.optional(l.array(l.ref<ConflictInfo>((() => conflictInfo) as any))), 24 22 }), 25 25 - ) 26 26 - export { main } 23 23 + ); 24 24 + export { main }; 27 25 28 28 - export type $Params = l.InferMethodParams<typeof main> 29 29 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 30 30 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 31 31 - typeof main, 32 32 - B 33 33 - > 26 26 + export type $Params = l.InferMethodParams<typeof main>; 27 27 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 28 28 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 34 29 35 30 export const $lxm = main.nsid, 36 31 $params = main.parameters, 37 37 - $output = main.output 32 32 + $output = main.output; 38 33 39 34 type ConflictInfo = { 40 40 - $type?: 'sh.tangled.git.temp.analyzeMerge#conflictInfo' 35 35 + $type?: "sh.tangled.git.temp.analyzeMerge#conflictInfo"; 41 36 42 37 /** 43 38 * Name of the conflicted file 44 39 */ 45 45 - filename: string 40 40 + filename: string; 46 41 47 42 /** 48 43 * Reason for the conflict 49 44 */ 50 50 - reason: string 51 51 - } 45 45 + reason: string; 46 46 + }; 52 47 53 53 - export type { ConflictInfo } 48 48 + export type { ConflictInfo }; 54 49 55 50 const conflictInfo = l.typedObject<ConflictInfo>( 56 51 $nsid, 57 57 - 'conflictInfo', 52 52 + "conflictInfo", 58 53 l.object({ filename: l.string(), reason: l.string() }), 59 59 - ) 54 54 + ); 60 55 61 61 - export { conflictInfo } 56 56 + export { conflictInfo };

+2 -2

api/src/lexicons/sh/tangled/git/temp/analyzeMerge.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './analyzeMerge.defs.ts' 6 6 - export * as $defs from './analyzeMerge.defs.ts' 5 5 + export * from "./analyzeMerge.defs.ts"; 6 6 + export * as $defs from "./analyzeMerge.defs.ts";

+66 -66

api/src/lexicons/sh/tangled/git/temp/defs.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.git.temp.defs' 7 7 + const $nsid = "sh.tangled.git.temp.defs"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 /** blob metadata. This object doesn't include the blob content */ 12 12 type Blob = { 13 13 - $type?: 'sh.tangled.git.temp.defs#blob' 13 13 + $type?: "sh.tangled.git.temp.defs#blob"; 14 14 15 15 /** 16 16 * The file name 17 17 */ 18 18 - name: string 19 19 - mode: string 18 18 + name: string; 19 19 + mode: string; 20 20 21 21 /** 22 22 * File size in bytes 23 23 */ 24 24 - size: number 25 25 - lastCommit: Commit 24 24 + size: number; 25 25 + lastCommit: Commit; 26 26 27 27 /** 28 28 * Submodule information if path is a submodule 29 29 */ 30 30 - submodule?: Submodule 31 31 - } 30 30 + submodule?: Submodule; 31 31 + }; 32 32 33 33 - export type { Blob } 33 33 + export type { Blob }; 34 34 35 35 /** blob metadata. This object doesn't include the blob content */ 36 36 const blob = l.typedObject<Blob>( 37 37 $nsid, 38 38 - 'blob', 38 38 + "blob", 39 39 l.object({ 40 40 name: l.string(), 41 41 mode: l.string(), ··· 43 43 lastCommit: l.ref<Commit>((() => commit) as any), 44 44 submodule: l.optional(l.ref<Submodule>((() => submodule) as any)), 45 45 }), 46 46 - ) 46 46 + ); 47 47 48 48 - export { blob } 48 48 + export { blob }; 49 49 50 50 type Branch = { 51 51 - $type?: 'sh.tangled.git.temp.defs#branch' 51 51 + $type?: "sh.tangled.git.temp.defs#branch"; 52 52 53 53 /** 54 54 * branch name 55 55 */ 56 56 - name: string 56 56 + name: string; 57 57 58 58 /** 59 59 * hydrated commit object 60 60 */ 61 61 - commit: Commit 62 62 - } 61 61 + commit: Commit; 62 62 + }; 63 63 64 64 - export type { Branch } 64 64 + export type { Branch }; 65 65 66 66 const branch = l.typedObject<Branch>( 67 67 $nsid, 68 68 - 'branch', 68 68 + "branch", 69 69 l.object({ name: l.string(), commit: l.ref<Commit>((() => commit) as any) }), 70 70 - ) 70 70 + ); 71 71 72 72 - export { branch } 72 72 + export { branch }; 73 73 74 74 type Tag = { 75 75 - $type?: 'sh.tangled.git.temp.defs#tag' 75 75 + $type?: "sh.tangled.git.temp.defs#tag"; 76 76 77 77 /** 78 78 * tag name 79 79 */ 80 80 - name: string 81 81 - tagger: Signature 82 82 - message?: string 83 83 - target: l.LexMap 84 84 - } 80 80 + name: string; 81 81 + tagger: Signature; 82 82 + message?: string; 83 83 + target: l.LexMap; 84 84 + }; 85 85 86 86 - export type { Tag } 86 86 + export type { Tag }; 87 87 88 88 const tag = l.typedObject<Tag>( 89 89 $nsid, 90 90 - 'tag', 90 90 + "tag", 91 91 l.object({ 92 92 name: l.string(), 93 93 tagger: l.ref<Signature>((() => signature) as any), 94 94 message: l.optional(l.string()), 95 95 target: l.lexMap(), 96 96 }), 97 97 - ) 97 97 + ); 98 98 99 99 - export { tag } 99 99 + export { tag }; 100 100 101 101 type Commit = { 102 102 - $type?: 'sh.tangled.git.temp.defs#commit' 103 103 - hash: Hash 104 104 - author: Signature 105 105 - committer: Signature 106 106 - message: string 107 107 - tree: Hash 108 108 - } 102 102 + $type?: "sh.tangled.git.temp.defs#commit"; 103 103 + hash: Hash; 104 104 + author: Signature; 105 105 + committer: Signature; 106 106 + message: string; 107 107 + tree: Hash; 108 108 + }; 109 109 110 110 - export type { Commit } 110 110 + export type { Commit }; 111 111 112 112 const commit = l.typedObject<Commit>( 113 113 $nsid, 114 114 - 'commit', 114 114 + "commit", 115 115 l.object({ 116 116 hash: l.ref<Hash>((() => hash) as any), 117 117 author: l.ref<Signature>((() => signature) as any), ··· 119 119 message: l.string(), 120 120 tree: l.ref<Hash>((() => hash) as any), 121 121 }), 122 122 - ) 122 122 + ); 123 123 124 124 - export { commit } 124 124 + export { commit }; 125 125 126 126 - type Hash = string 126 126 + type Hash = string; 127 127 128 128 - export type { Hash } 128 128 + export type { Hash }; 129 129 130 130 - const hash = l.string() 130 130 + const hash = l.string(); 131 131 132 132 - export { hash } 132 132 + export { hash }; 133 133 134 134 type Signature = { 135 135 - $type?: 'sh.tangled.git.temp.defs#signature' 135 135 + $type?: "sh.tangled.git.temp.defs#signature"; 136 136 137 137 /** 138 138 * Person name 139 139 */ 140 140 - name: string 140 140 + name: string; 141 141 142 142 /** 143 143 * Person email 144 144 */ 145 145 - email: string 145 145 + email: string; 146 146 147 147 /** 148 148 * Timestamp of the signature 149 149 */ 150 150 - when: l.DatetimeString 151 151 - } 150 150 + when: l.DatetimeString; 151 151 + }; 152 152 153 153 - export type { Signature } 153 153 + export type { Signature }; 154 154 155 155 const signature = l.typedObject<Signature>( 156 156 $nsid, 157 157 - 'signature', 157 157 + "signature", 158 158 l.object({ 159 159 name: l.string(), 160 160 email: l.string(), 161 161 - when: l.string({ format: 'datetime' }), 161 161 + when: l.string({ format: "datetime" }), 162 162 }), 163 163 - ) 163 163 + ); 164 164 165 165 - export { signature } 165 165 + export { signature }; 166 166 167 167 type Submodule = { 168 168 - $type?: 'sh.tangled.git.temp.defs#submodule' 168 168 + $type?: "sh.tangled.git.temp.defs#submodule"; 169 169 170 170 /** 171 171 * Submodule name 172 172 */ 173 173 - name: string 173 173 + name: string; 174 174 175 175 /** 176 176 * Submodule repository URL 177 177 */ 178 178 - url: string 178 178 + url: string; 179 179 180 180 /** 181 181 * Branch to track in the submodule 182 182 */ 183 183 - branch?: string 184 184 - } 183 183 + branch?: string; 184 184 + }; 185 185 186 186 - export type { Submodule } 186 186 + export type { Submodule }; 187 187 188 188 const submodule = l.typedObject<Submodule>( 189 189 $nsid, 190 190 - 'submodule', 190 190 + "submodule", 191 191 l.object({ 192 192 name: l.string(), 193 193 url: l.string(), 194 194 branch: l.optional(l.string()), 195 195 }), 196 196 - ) 196 196 + ); 197 197 198 198 - export { submodule } 198 198 + export { submodule };

+2 -2

api/src/lexicons/sh/tangled/git/temp/defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './defs.defs.ts' 6 6 - export * as $defs from './defs.defs.ts' 5 5 + export * from "./defs.defs.ts"; 6 6 + export * as $defs from "./defs.defs.ts";

+13 -19

api/src/lexicons/sh/tangled/git/temp/getArchive.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.git.temp.getArchive' 7 7 + const $nsid = "sh.tangled.git.temp.getArchive"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 const main = l.query( 12 12 $nsid, 13 13 l.params({ 14 14 - repo: l.string({ format: 'at-uri' }), 14 14 + repo: l.string({ format: "at-uri" }), 15 15 ref: l.string(), 16 16 format: l.optional( 17 17 - l.withDefault( 18 18 - l.enum(['tar', 'zip', 'tar.gz', 'tar.bz2', 'tar.xz']), 19 19 - 'tar.gz', 20 20 - ), 17 17 + l.withDefault(l.enum(["tar", "zip", "tar.gz", "tar.bz2", "tar.xz"]), "tar.gz"), 21 18 ), 22 19 prefix: l.optional(l.string()), 23 20 }), 24 24 - l.payload('*/*'), 25 25 - ['RepoNotFound', 'RefNotFound', 'InvalidRequest', 'ArchiveError'], 26 26 - ) 27 27 - export { main } 21 21 + l.payload("*/*"), 22 22 + ["RepoNotFound", "RefNotFound", "InvalidRequest", "ArchiveError"], 23 23 + ); 24 24 + export { main }; 28 25 29 29 - export type $Params = l.InferMethodParams<typeof main> 26 26 + export type $Params = l.InferMethodParams<typeof main>; 30 27 /** Binary archive data */ 31 31 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 28 28 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 32 29 /** Binary archive data */ 33 33 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 34 34 - typeof main, 35 35 - B 36 36 - > 30 30 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 37 31 38 32 export const $lxm = main.nsid, 39 33 $params = main.parameters, 40 40 - $output = main.output 34 34 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/git/temp/getArchive.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './getArchive.defs.ts' 6 6 - export * as $defs from './getArchive.defs.ts' 5 5 + export * from "./getArchive.defs.ts"; 6 6 + export * as $defs from "./getArchive.defs.ts";

+13 -16

api/src/lexicons/sh/tangled/git/temp/getBlob.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.git.temp.getBlob' 7 7 + const $nsid = "sh.tangled.git.temp.getBlob"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 const main = l.query( 12 12 $nsid, 13 13 l.params({ 14 14 - repo: l.string({ format: 'at-uri' }), 15 15 - ref: l.optional(l.withDefault(l.string(), 'HEAD')), 14 14 + repo: l.string({ format: "at-uri" }), 15 15 + ref: l.optional(l.withDefault(l.string(), "HEAD")), 16 16 path: l.string(), 17 17 }), 18 18 - l.payload('*/*'), 19 19 - ['RepoNotFound', 'BlobNotFound', 'InvalidRequest'], 20 20 - ) 21 21 - export { main } 18 18 + l.payload("*/*"), 19 19 + ["RepoNotFound", "BlobNotFound", "InvalidRequest"], 20 20 + ); 21 21 + export { main }; 22 22 23 23 - export type $Params = l.InferMethodParams<typeof main> 23 23 + export type $Params = l.InferMethodParams<typeof main>; 24 24 /** raw blob served in octet-stream */ 25 25 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 25 25 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 26 26 /** raw blob served in octet-stream */ 27 27 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 28 28 - typeof main, 29 29 - B 30 30 - > 27 27 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 31 28 32 29 export const $lxm = main.nsid, 33 30 $params = main.parameters, 34 34 - $output = main.output 31 31 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/git/temp/getBlob.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './getBlob.defs.ts' 6 6 - export * as $defs from './getBlob.defs.ts' 5 5 + export * from "./getBlob.defs.ts"; 6 6 + export * as $defs from "./getBlob.defs.ts";

+14 -19

api/src/lexicons/sh/tangled/git/temp/getBranch.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 6 6 - import * as TempDefs from './defs.defs.ts' 5 5 + import { l } from "@atproto/lex"; 6 6 + import * as TempDefs from "./defs.defs.ts"; 7 7 8 8 - const $nsid = 'sh.tangled.git.temp.getBranch' 8 8 + const $nsid = "sh.tangled.git.temp.getBranch"; 9 9 10 10 - export { $nsid } 10 10 + export { $nsid }; 11 11 12 12 const main = l.query( 13 13 $nsid, 14 14 - l.params({ repo: l.string({ format: 'at-uri' }), name: l.string() }), 14 14 + l.params({ repo: l.string({ format: "at-uri" }), name: l.string() }), 15 15 l.jsonPayload({ 16 16 name: l.string(), 17 17 hash: l.string(), 18 18 - when: l.string({ format: 'datetime' }), 18 18 + when: l.string({ format: "datetime" }), 19 19 message: l.optional(l.string()), 20 20 - author: l.optional( 21 21 - l.ref<TempDefs.Signature>((() => TempDefs.signature) as any), 22 22 - ), 20 20 + author: l.optional(l.ref<TempDefs.Signature>((() => TempDefs.signature) as any)), 23 21 }), 24 24 - ['RepoNotFound', 'BranchNotFound', 'InvalidRequest'], 25 25 - ) 26 26 - export { main } 22 22 + ["RepoNotFound", "BranchNotFound", "InvalidRequest"], 23 23 + ); 24 24 + export { main }; 27 25 28 28 - export type $Params = l.InferMethodParams<typeof main> 29 29 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 30 30 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 31 31 - typeof main, 32 32 - B 33 33 - > 26 26 + export type $Params = l.InferMethodParams<typeof main>; 27 27 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 28 28 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 34 29 35 30 export const $lxm = main.nsid, 36 31 $params = main.parameters, 37 37 - $output = main.output 32 32 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/git/temp/getBranch.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './getBranch.defs.ts' 6 6 - export * as $defs from './getBranch.defs.ts' 5 5 + export * from "./getBranch.defs.ts"; 6 6 + export * as $defs from "./getBranch.defs.ts";

+13 -19

api/src/lexicons/sh/tangled/git/temp/getCommit.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 6 6 - import * as TempDefs from './defs.defs.ts' 5 5 + import { l } from "@atproto/lex"; 6 6 + import * as TempDefs from "./defs.defs.ts"; 7 7 8 8 - const $nsid = 'sh.tangled.git.temp.getCommit' 8 8 + const $nsid = "sh.tangled.git.temp.getCommit"; 9 9 10 10 - export { $nsid } 10 10 + export { $nsid }; 11 11 12 12 /** resolve commit from given ref */ 13 13 const main = l.query( 14 14 $nsid, 15 15 - l.params({ repo: l.string({ format: 'at-uri' }), ref: l.string() }), 16 16 - l.payload( 17 17 - 'application/json', 18 18 - l.ref<TempDefs.Commit>((() => TempDefs.commit) as any), 19 19 - ), 20 20 - ['RepoNotFound', 'CommitNotFound', 'InvalidRequest'], 21 21 - ) 22 22 - export { main } 15 15 + l.params({ repo: l.string({ format: "at-uri" }), ref: l.string() }), 16 16 + l.payload("application/json", l.ref<TempDefs.Commit>((() => TempDefs.commit) as any)), 17 17 + ["RepoNotFound", "CommitNotFound", "InvalidRequest"], 18 18 + ); 19 19 + export { main }; 23 20 24 24 - export type $Params = l.InferMethodParams<typeof main> 25 25 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 26 26 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 27 27 - typeof main, 28 28 - B 29 29 - > 21 21 + export type $Params = l.InferMethodParams<typeof main>; 22 22 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 23 23 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 30 24 31 25 export const $lxm = main.nsid, 32 26 $params = main.parameters, 33 33 - $output = main.output 27 27 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/git/temp/getCommit.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './getCommit.defs.ts' 6 6 - export * as $defs from './getCommit.defs.ts' 5 5 + export * from "./getCommit.defs.ts"; 6 6 + export * as $defs from "./getCommit.defs.ts";

+12 -15

api/src/lexicons/sh/tangled/git/temp/getDiff.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.git.temp.getDiff' 7 7 + const $nsid = "sh.tangled.git.temp.getDiff"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 const main = l.query( 12 12 $nsid, 13 13 l.params({ 14 14 - repo: l.string({ format: 'at-uri' }), 14 14 + repo: l.string({ format: "at-uri" }), 15 15 rev1: l.string(), 16 16 rev2: l.string(), 17 17 }), 18 18 - l.payload('*/*'), 19 19 - ['RepoNotFound', 'RevisionNotFound', 'InvalidRequest', 'CompareError'], 20 20 - ) 21 21 - export { main } 18 18 + l.payload("*/*"), 19 19 + ["RepoNotFound", "RevisionNotFound", "InvalidRequest", "CompareError"], 20 20 + ); 21 21 + export { main }; 22 22 23 23 - export type $Params = l.InferMethodParams<typeof main> 23 23 + export type $Params = l.InferMethodParams<typeof main>; 24 24 /** Compare output in application/json */ 25 25 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 25 25 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 26 26 /** Compare output in application/json */ 27 27 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 28 28 - typeof main, 29 29 - B 30 30 - > 27 27 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 31 28 32 29 export const $lxm = main.nsid, 33 30 $params = main.parameters, 34 34 - $output = main.output 31 31 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/git/temp/getDiff.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './getDiff.defs.ts' 6 6 - export * as $defs from './getDiff.defs.ts' 5 5 + export * from "./getDiff.defs.ts"; 6 6 + export * as $defs from "./getDiff.defs.ts";

+14 -20

api/src/lexicons/sh/tangled/git/temp/getEntity.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 6 6 - import * as TempDefs from './defs.defs.ts' 5 5 + import { l } from "@atproto/lex"; 6 6 + import * as TempDefs from "./defs.defs.ts"; 7 7 8 8 - const $nsid = 'sh.tangled.git.temp.getEntity' 8 8 + const $nsid = "sh.tangled.git.temp.getEntity"; 9 9 10 10 - export { $nsid } 10 10 + export { $nsid }; 11 11 12 12 /** get metadata of blob by ref and path */ 13 13 const main = l.query( 14 14 $nsid, 15 15 l.params({ 16 16 - repo: l.string({ format: 'at-uri' }), 17 17 - ref: l.optional(l.withDefault(l.string(), 'HEAD')), 16 16 + repo: l.string({ format: "at-uri" }), 17 17 + ref: l.optional(l.withDefault(l.string(), "HEAD")), 18 18 path: l.string(), 19 19 }), 20 20 - l.payload( 21 21 - 'application/json', 22 22 - l.ref<TempDefs.Blob>((() => TempDefs.blob) as any), 23 23 - ), 24 24 - ['RepoNotFound', 'BlobNotFound', 'InvalidRequest'], 25 25 - ) 26 26 - export { main } 20 20 + l.payload("application/json", l.ref<TempDefs.Blob>((() => TempDefs.blob) as any)), 21 21 + ["RepoNotFound", "BlobNotFound", "InvalidRequest"], 22 22 + ); 23 23 + export { main }; 27 24 28 28 - export type $Params = l.InferMethodParams<typeof main> 29 29 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 30 30 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 31 31 - typeof main, 32 32 - B 33 33 - > 25 25 + export type $Params = l.InferMethodParams<typeof main>; 26 26 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 27 27 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 34 28 35 29 export const $lxm = main.nsid, 36 30 $params = main.parameters, 37 37 - $output = main.output 31 31 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/git/temp/getEntity.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './getEntity.defs.ts' 6 6 - export * as $defs from './getEntity.defs.ts' 5 5 + export * from "./getEntity.defs.ts"; 6 6 + export * as $defs from "./getEntity.defs.ts";

+13 -19

api/src/lexicons/sh/tangled/git/temp/getHead.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 6 6 - import * as TempDefs from './defs.defs.ts' 5 5 + import { l } from "@atproto/lex"; 6 6 + import * as TempDefs from "./defs.defs.ts"; 7 7 8 8 - const $nsid = 'sh.tangled.git.temp.getHead' 8 8 + const $nsid = "sh.tangled.git.temp.getHead"; 9 9 10 10 - export { $nsid } 10 10 + export { $nsid }; 11 11 12 12 const main = l.query( 13 13 $nsid, 14 14 - l.params({ repo: l.string({ format: 'at-uri' }) }), 15 15 - l.payload( 16 16 - 'application/json', 17 17 - l.ref<TempDefs.Branch>((() => TempDefs.branch) as any), 18 18 - ), 19 19 - ['RepoNotFound', 'InvalidRequest'], 20 20 - ) 21 21 - export { main } 14 14 + l.params({ repo: l.string({ format: "at-uri" }) }), 15 15 + l.payload("application/json", l.ref<TempDefs.Branch>((() => TempDefs.branch) as any)), 16 16 + ["RepoNotFound", "InvalidRequest"], 17 17 + ); 18 18 + export { main }; 22 19 23 23 - export type $Params = l.InferMethodParams<typeof main> 24 24 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 25 25 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 26 26 - typeof main, 27 27 - B 28 28 - > 20 20 + export type $Params = l.InferMethodParams<typeof main>; 21 21 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 22 22 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 29 23 30 24 export const $lxm = main.nsid, 31 25 $params = main.parameters, 32 32 - $output = main.output 26 26 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/git/temp/getHead.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './getHead.defs.ts' 6 6 - export * as $defs from './getHead.defs.ts' 5 5 + export * from "./getHead.defs.ts"; 6 6 + export * as $defs from "./getHead.defs.ts";

+12 -15

api/src/lexicons/sh/tangled/git/temp/getTag.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.git.temp.getTag' 7 7 + const $nsid = "sh.tangled.git.temp.getTag"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 const main = l.query( 12 12 $nsid, 13 13 - l.params({ repo: l.string({ format: 'at-uri' }), tag: l.string() }), 14 14 - l.payload('*/*'), 15 15 - ['RepoNotFound', 'TagNotFound', 'InvalidRequest'], 16 16 - ) 17 17 - export { main } 13 13 + l.params({ repo: l.string({ format: "at-uri" }), tag: l.string() }), 14 14 + l.payload("*/*"), 15 15 + ["RepoNotFound", "TagNotFound", "InvalidRequest"], 16 16 + ); 17 17 + export { main }; 18 18 19 19 - export type $Params = l.InferMethodParams<typeof main> 20 20 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 21 21 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 22 22 - typeof main, 23 23 - B 24 24 - > 19 19 + export type $Params = l.InferMethodParams<typeof main>; 20 20 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 21 21 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 25 22 26 23 export const $lxm = main.nsid, 27 24 $params = main.parameters, 28 28 - $output = main.output 25 25 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/git/temp/getTag.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './getTag.defs.ts' 6 6 - export * as $defs from './getTag.defs.ts' 5 5 + export * from "./getTag.defs.ts"; 6 6 + export * as $defs from "./getTag.defs.ts";

+51 -54

api/src/lexicons/sh/tangled/git/temp/getTree.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.git.temp.getTree' 7 7 + const $nsid = "sh.tangled.git.temp.getTree"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 const main = l.query( 12 12 $nsid, 13 13 l.params({ 14 14 - repo: l.string({ format: 'at-uri' }), 14 14 + repo: l.string({ format: "at-uri" }), 15 15 ref: l.string(), 16 16 - path: l.optional(l.withDefault(l.string(), '')), 16 16 + path: l.optional(l.withDefault(l.string(), "")), 17 17 }), 18 18 l.jsonPayload({ 19 19 ref: l.string(), ··· 23 23 lastCommit: l.optional(l.ref<LastCommit>((() => lastCommit) as any)), 24 24 files: l.array(l.ref<TreeEntry>((() => treeEntry) as any)), 25 25 }), 26 26 - ['RepoNotFound', 'RefNotFound', 'PathNotFound', 'InvalidRequest'], 27 27 - ) 28 28 - export { main } 26 26 + ["RepoNotFound", "RefNotFound", "PathNotFound", "InvalidRequest"], 27 27 + ); 28 28 + export { main }; 29 29 30 30 - export type $Params = l.InferMethodParams<typeof main> 31 31 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 32 32 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 33 33 - typeof main, 34 34 - B 35 35 - > 30 30 + export type $Params = l.InferMethodParams<typeof main>; 31 31 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 32 32 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 36 33 37 34 export const $lxm = main.nsid, 38 35 $params = main.parameters, 39 39 - $output = main.output 36 36 + $output = main.output; 40 37 41 38 type Readme = { 42 42 - $type?: 'sh.tangled.git.temp.getTree#readme' 39 39 + $type?: "sh.tangled.git.temp.getTree#readme"; 43 40 44 41 /** 45 42 * Name of the readme file 46 43 */ 47 47 - filename: string 44 44 + filename: string; 48 45 49 46 /** 50 47 * Contents of the readme file 51 48 */ 52 52 - contents: string 53 53 - } 49 49 + contents: string; 50 50 + }; 54 51 55 55 - export type { Readme } 52 52 + export type { Readme }; 56 53 57 54 const readme = l.typedObject<Readme>( 58 55 $nsid, 59 59 - 'readme', 56 56 + "readme", 60 57 l.object({ filename: l.string(), contents: l.string() }), 61 61 - ) 58 58 + ); 62 59 63 63 - export { readme } 60 60 + export { readme }; 64 61 65 62 type TreeEntry = { 66 66 - $type?: 'sh.tangled.git.temp.getTree#treeEntry' 63 63 + $type?: "sh.tangled.git.temp.getTree#treeEntry"; 67 64 68 65 /** 69 66 * Relative file or directory name 70 67 */ 71 71 - name: string 68 68 + name: string; 72 69 73 70 /** 74 71 * File mode 75 72 */ 76 76 - mode: string 73 73 + mode: string; 77 74 78 75 /** 79 76 * File size in bytes 80 77 */ 81 81 - size: number 82 82 - last_commit?: LastCommit 83 83 - } 78 78 + size: number; 79 79 + last_commit?: LastCommit; 80 80 + }; 84 81 85 85 - export type { TreeEntry } 82 82 + export type { TreeEntry }; 86 83 87 84 const treeEntry = l.typedObject<TreeEntry>( 88 85 $nsid, 89 89 - 'treeEntry', 86 86 + "treeEntry", 90 87 l.object({ 91 88 name: l.string(), 92 89 mode: l.string(), 93 90 size: l.integer(), 94 91 last_commit: l.optional(l.ref<LastCommit>((() => lastCommit) as any)), 95 92 }), 96 96 - ) 93 93 + ); 97 94 98 98 - export { treeEntry } 95 95 + export { treeEntry }; 99 96 100 97 type LastCommit = { 101 101 - $type?: 'sh.tangled.git.temp.getTree#lastCommit' 98 98 + $type?: "sh.tangled.git.temp.getTree#lastCommit"; 102 99 103 100 /** 104 101 * Commit hash 105 102 */ 106 106 - hash: string 103 103 + hash: string; 107 104 108 105 /** 109 106 * Commit message 110 107 */ 111 111 - message: string 112 112 - author?: Signature 108 108 + message: string; 109 109 + author?: Signature; 113 110 114 111 /** 115 112 * Commit timestamp 116 113 */ 117 117 - when: l.DatetimeString 118 118 - } 114 114 + when: l.DatetimeString; 115 115 + }; 119 116 120 120 - export type { LastCommit } 117 117 + export type { LastCommit }; 121 118 122 119 const lastCommit = l.typedObject<LastCommit>( 123 120 $nsid, 124 124 - 'lastCommit', 121 121 + "lastCommit", 125 122 l.object({ 126 123 hash: l.string(), 127 124 message: l.string(), 128 125 author: l.optional(l.ref<Signature>((() => signature) as any)), 129 129 - when: l.string({ format: 'datetime' }), 126 126 + when: l.string({ format: "datetime" }), 130 127 }), 131 131 - ) 128 128 + ); 132 129 133 133 - export { lastCommit } 130 130 + export { lastCommit }; 134 131 135 132 type Signature = { 136 136 - $type?: 'sh.tangled.git.temp.getTree#signature' 133 133 + $type?: "sh.tangled.git.temp.getTree#signature"; 137 134 138 135 /** 139 136 * Author name 140 137 */ 141 141 - name: string 138 138 + name: string; 142 139 143 140 /** 144 141 * Author email 145 142 */ 146 146 - email: string 143 143 + email: string; 147 144 148 145 /** 149 146 * Author timestamp 150 147 */ 151 151 - when: l.DatetimeString 152 152 - } 148 148 + when: l.DatetimeString; 149 149 + }; 153 150 154 154 - export type { Signature } 151 151 + export type { Signature }; 155 152 156 153 const signature = l.typedObject<Signature>( 157 154 $nsid, 158 158 - 'signature', 155 155 + "signature", 159 156 l.object({ 160 157 name: l.string(), 161 158 email: l.string(), 162 162 - when: l.string({ format: 'datetime' }), 159 159 + when: l.string({ format: "datetime" }), 163 160 }), 164 164 - ) 161 161 + ); 165 162 166 166 - export { signature } 163 163 + export { signature };

+2 -2

api/src/lexicons/sh/tangled/git/temp/getTree.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './getTree.defs.ts' 6 6 - export * as $defs from './getTree.defs.ts' 5 5 + export * from "./getTree.defs.ts"; 6 6 + export * as $defs from "./getTree.defs.ts";

+13 -18

api/src/lexicons/sh/tangled/git/temp/listBranches.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.git.temp.listBranches' 7 7 + const $nsid = "sh.tangled.git.temp.listBranches"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 const main = l.query( 12 12 $nsid, 13 13 l.params({ 14 14 - repo: l.string({ format: 'at-uri' }), 15 15 - limit: l.optional( 16 16 - l.withDefault(l.integer({ minimum: 1, maximum: 100 }), 50), 17 17 - ), 14 14 + repo: l.string({ format: "at-uri" }), 15 15 + limit: l.optional(l.withDefault(l.integer({ minimum: 1, maximum: 100 }), 50)), 18 16 cursor: l.optional(l.string()), 19 17 }), 20 20 - l.payload('*/*'), 21 21 - ['RepoNotFound', 'InvalidRequest'], 22 22 - ) 23 23 - export { main } 18 18 + l.payload("*/*"), 19 19 + ["RepoNotFound", "InvalidRequest"], 20 20 + ); 21 21 + export { main }; 24 22 25 25 - export type $Params = l.InferMethodParams<typeof main> 26 26 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 27 27 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 28 28 - typeof main, 29 29 - B 30 30 - > 23 23 + export type $Params = l.InferMethodParams<typeof main>; 24 24 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 25 25 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 31 26 32 27 export const $lxm = main.nsid, 33 28 $params = main.parameters, 34 34 - $output = main.output 29 29 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/git/temp/listBranches.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './listBranches.defs.ts' 6 6 - export * as $defs from './listBranches.defs.ts' 5 5 + export * from "./listBranches.defs.ts"; 6 6 + export * as $defs from "./listBranches.defs.ts";

+13 -18

api/src/lexicons/sh/tangled/git/temp/listCommits.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.git.temp.listCommits' 7 7 + const $nsid = "sh.tangled.git.temp.listCommits"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 const main = l.query( 12 12 $nsid, 13 13 l.params({ 14 14 - repo: l.string({ format: 'at-uri' }), 14 14 + repo: l.string({ format: "at-uri" }), 15 15 ref: l.optional(l.string()), 16 16 - limit: l.optional( 17 17 - l.withDefault(l.integer({ minimum: 1, maximum: 100 }), 50), 18 18 - ), 16 16 + limit: l.optional(l.withDefault(l.integer({ minimum: 1, maximum: 100 }), 50)), 19 17 cursor: l.optional(l.string()), 20 18 }), 21 21 - l.payload('*/*'), 22 22 - ['RepoNotFound', 'RefNotFound', 'PathNotFound', 'InvalidRequest'], 23 23 - ) 24 24 - export { main } 19 19 + l.payload("*/*"), 20 20 + ["RepoNotFound", "RefNotFound", "PathNotFound", "InvalidRequest"], 21 21 + ); 22 22 + export { main }; 25 23 26 26 - export type $Params = l.InferMethodParams<typeof main> 27 27 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 28 28 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 29 29 - typeof main, 30 30 - B 31 31 - > 24 24 + export type $Params = l.InferMethodParams<typeof main>; 25 25 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 26 26 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 32 27 33 28 export const $lxm = main.nsid, 34 29 $params = main.parameters, 35 35 - $output = main.output 30 30 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/git/temp/listCommits.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './listCommits.defs.ts' 6 6 - export * as $defs from './listCommits.defs.ts' 5 5 + export * from "./listCommits.defs.ts"; 6 6 + export * as $defs from "./listCommits.defs.ts";

+24 -27

api/src/lexicons/sh/tangled/git/temp/listLanguages.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.git.temp.listLanguages' 7 7 + const $nsid = "sh.tangled.git.temp.listLanguages"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 const main = l.query( 12 12 $nsid, 13 13 l.params({ 14 14 - repo: l.string({ format: 'at-uri' }), 15 15 - ref: l.optional(l.withDefault(l.string(), 'HEAD')), 14 14 + repo: l.string({ format: "at-uri" }), 15 15 + ref: l.optional(l.withDefault(l.string(), "HEAD")), 16 16 }), 17 17 l.jsonPayload({ 18 18 ref: l.string(), ··· 20 20 totalSize: l.optional(l.integer()), 21 21 totalFiles: l.optional(l.integer()), 22 22 }), 23 23 - ['RepoNotFound', 'RefNotFound', 'InvalidRequest'], 24 24 - ) 25 25 - export { main } 23 23 + ["RepoNotFound", "RefNotFound", "InvalidRequest"], 24 24 + ); 25 25 + export { main }; 26 26 27 27 - export type $Params = l.InferMethodParams<typeof main> 28 28 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 29 29 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 30 30 - typeof main, 31 31 - B 32 32 - > 27 27 + export type $Params = l.InferMethodParams<typeof main>; 28 28 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 29 29 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 33 30 34 31 export const $lxm = main.nsid, 35 32 $params = main.parameters, 36 36 - $output = main.output 33 33 + $output = main.output; 37 34 38 35 type Language = { 39 39 - $type?: 'sh.tangled.git.temp.listLanguages#language' 36 36 + $type?: "sh.tangled.git.temp.listLanguages#language"; 40 37 41 38 /** 42 39 * Programming language name 43 40 */ 44 44 - name: string 41 41 + name: string; 45 42 46 43 /** 47 44 * Total size of files in this language (bytes) 48 45 */ 49 49 - size: number 46 46 + size: number; 50 47 51 48 /** 52 49 * Percentage of total codebase (0-100) 53 50 */ 54 54 - percentage: number 51 51 + percentage: number; 55 52 56 53 /** 57 54 * Number of files in this language 58 55 */ 59 59 - fileCount?: number 56 56 + fileCount?: number; 60 57 61 58 /** 62 59 * Hex color code for this language 63 60 */ 64 64 - color?: string 61 61 + color?: string; 65 62 66 63 /** 67 64 * File extensions associated with this language 68 65 */ 69 69 - extensions?: string[] 70 70 - } 66 66 + extensions?: string[]; 67 67 + }; 71 68 72 72 - export type { Language } 69 69 + export type { Language }; 73 70 74 71 const language = l.typedObject<Language>( 75 72 $nsid, 76 76 - 'language', 73 73 + "language", 77 74 l.object({ 78 75 name: l.string(), 79 76 size: l.integer(), ··· 82 79 color: l.optional(l.string()), 83 80 extensions: l.optional(l.array(l.string())), 84 81 }), 85 85 - ) 82 82 + ); 86 83 87 87 - export { language } 84 84 + export { language };

+2 -2

api/src/lexicons/sh/tangled/git/temp/listLanguages.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './listLanguages.defs.ts' 6 6 - export * as $defs from './listLanguages.defs.ts' 5 5 + export * from "./listLanguages.defs.ts"; 6 6 + export * as $defs from "./listLanguages.defs.ts";

+13 -18

api/src/lexicons/sh/tangled/git/temp/listTags.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.git.temp.listTags' 7 7 + const $nsid = "sh.tangled.git.temp.listTags"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 const main = l.query( 12 12 $nsid, 13 13 l.params({ 14 14 - repo: l.string({ format: 'at-uri' }), 15 15 - limit: l.optional( 16 16 - l.withDefault(l.integer({ minimum: 1, maximum: 100 }), 50), 17 17 - ), 14 14 + repo: l.string({ format: "at-uri" }), 15 15 + limit: l.optional(l.withDefault(l.integer({ minimum: 1, maximum: 100 }), 50)), 18 16 cursor: l.optional(l.string()), 19 17 }), 20 20 - l.payload('*/*'), 21 21 - ['RepoNotFound', 'InvalidRequest'], 22 22 - ) 23 23 - export { main } 18 18 + l.payload("*/*"), 19 19 + ["RepoNotFound", "InvalidRequest"], 20 20 + ); 21 21 + export { main }; 24 22 25 25 - export type $Params = l.InferMethodParams<typeof main> 26 26 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 27 27 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 28 28 - typeof main, 29 29 - B 30 30 - > 23 23 + export type $Params = l.InferMethodParams<typeof main>; 24 24 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 25 25 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 31 26 32 27 export const $lxm = main.nsid, 33 28 $params = main.parameters, 34 34 - $output = main.output 29 29 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/git/temp/listTags.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './listTags.defs.ts' 6 6 - export * as $defs from './listTags.defs.ts' 5 5 + export * from "./listTags.defs.ts"; 6 6 + export * as $defs from "./listTags.defs.ts";

+2 -2

api/src/lexicons/sh/tangled/graph.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * as follow from './graph/follow.ts' 6 6 - export * as vouch from './graph/vouch.ts' 5 5 + export * as follow from "./graph/follow.ts"; 6 6 + export * as vouch from "./graph/vouch.ts";

+16 -16

api/src/lexicons/sh/tangled/graph/follow.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.graph.follow' 7 7 + const $nsid = "sh.tangled.graph.follow"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 type Main = { 12 12 - $type: 'sh.tangled.graph.follow' 13 13 - subject: l.DidString 14 14 - createdAt: l.DatetimeString 15 15 - } 12 12 + $type: "sh.tangled.graph.follow"; 13 13 + subject: l.DidString; 14 14 + createdAt: l.DatetimeString; 15 15 + }; 16 16 17 17 - export type { Main } 17 17 + export type { Main }; 18 18 19 19 - const main = l.record<'tid', Main>( 20 20 - 'tid', 19 19 + const main = l.record<"tid", Main>( 20 20 + "tid", 21 21 $nsid, 22 22 l.object({ 23 23 - subject: l.string({ format: 'did' }), 24 24 - createdAt: l.string({ format: 'datetime' }), 23 23 + subject: l.string({ format: "did" }), 24 24 + createdAt: l.string({ format: "datetime" }), 25 25 }), 26 26 - ) 26 26 + ); 27 27 28 28 - export { main } 28 28 + export { main }; 29 29 30 30 export const $isTypeOf = /*#__PURE__*/ main.isTypeOf.bind(main), 31 31 $build = /*#__PURE__*/ main.build.bind(main), 32 32 - $type = /*#__PURE__*/ main.$type 32 32 + $type = /*#__PURE__*/ main.$type; 33 33 export const $assert = /*#__PURE__*/ main.assert.bind(main), 34 34 $check = /*#__PURE__*/ main.check.bind(main), 35 35 $cast = /*#__PURE__*/ main.cast.bind(main), ··· 38 38 $parse = /*#__PURE__*/ main.parse.bind(main), 39 39 $safeParse = /*#__PURE__*/ main.safeParse.bind(main), 40 40 $validate = /*#__PURE__*/ main.validate.bind(main), 41 41 - $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main) 41 41 + $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main);

+2 -2

api/src/lexicons/sh/tangled/graph/follow.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './follow.defs.ts' 6 6 - export * as $defs from './follow.defs.ts' 5 5 + export * from "./follow.defs.ts"; 6 6 + export * as $defs from "./follow.defs.ts";

+17 -17

api/src/lexicons/sh/tangled/graph/vouch.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.graph.vouch' 7 7 + const $nsid = "sh.tangled.graph.vouch"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 type Main = { 12 12 - $type: 'sh.tangled.graph.vouch' 12 12 + $type: "sh.tangled.graph.vouch"; 13 13 14 14 /** 15 15 * Whether this user is being vouched for or denounced 16 16 */ 17 17 - kind: 'vouch' | 'denounce' 17 17 + kind: "vouch" | "denounce"; 18 18 19 19 /** 20 20 * The reason for this vouch/denouncement 21 21 */ 22 22 - reason?: string 23 23 - createdAt: l.DatetimeString 24 24 - } 22 22 + reason?: string; 23 23 + createdAt: l.DatetimeString; 24 24 + }; 25 25 26 26 - export type { Main } 26 26 + export type { Main }; 27 27 28 28 - const main = l.record<'any', Main>( 29 29 - 'any', 28 28 + const main = l.record<"any", Main>( 29 29 + "any", 30 30 $nsid, 31 31 l.object({ 32 32 - kind: l.withDefault(l.enum(['vouch', 'denounce']), 'vouch'), 32 32 + kind: l.withDefault(l.enum(["vouch", "denounce"]), "vouch"), 33 33 reason: l.optional(l.string({ maxGraphemes: 256, maxLength: 2560 })), 34 34 - createdAt: l.string({ format: 'datetime' }), 34 34 + createdAt: l.string({ format: "datetime" }), 35 35 }), 36 36 - ) 36 36 + ); 37 37 38 38 - export { main } 38 38 + export { main }; 39 39 40 40 export const $isTypeOf = /*#__PURE__*/ main.isTypeOf.bind(main), 41 41 $build = /*#__PURE__*/ main.build.bind(main), 42 42 - $type = /*#__PURE__*/ main.$type 42 42 + $type = /*#__PURE__*/ main.$type; 43 43 export const $assert = /*#__PURE__*/ main.assert.bind(main), 44 44 $check = /*#__PURE__*/ main.check.bind(main), 45 45 $cast = /*#__PURE__*/ main.cast.bind(main), ··· 48 48 $parse = /*#__PURE__*/ main.parse.bind(main), 49 49 $safeParse = /*#__PURE__*/ main.safeParse.bind(main), 50 50 $validate = /*#__PURE__*/ main.validate.bind(main), 51 51 - $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main) 51 51 + $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main);

+2 -2

api/src/lexicons/sh/tangled/graph/vouch.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './vouch.defs.ts' 6 6 - export * as $defs from './vouch.defs.ts' 5 5 + export * from "./vouch.defs.ts"; 6 6 + export * as $defs from "./vouch.defs.ts";

+12 -12

api/src/lexicons/sh/tangled/knot.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.knot' 7 7 + const $nsid = "sh.tangled.knot"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 - type Main = { $type: 'sh.tangled.knot'; createdAt: l.DatetimeString } 11 11 + type Main = { $type: "sh.tangled.knot"; createdAt: l.DatetimeString }; 12 12 13 13 - export type { Main } 13 13 + export type { Main }; 14 14 15 15 - const main = l.record<'any', Main>( 16 16 - 'any', 15 15 + const main = l.record<"any", Main>( 16 16 + "any", 17 17 $nsid, 18 18 - l.object({ createdAt: l.string({ format: 'datetime' }) }), 19 19 - ) 18 18 + l.object({ createdAt: l.string({ format: "datetime" }) }), 19 19 + ); 20 20 21 21 - export { main } 21 21 + export { main }; 22 22 23 23 export const $isTypeOf = /*#__PURE__*/ main.isTypeOf.bind(main), 24 24 $build = /*#__PURE__*/ main.build.bind(main), 25 25 - $type = /*#__PURE__*/ main.$type 25 25 + $type = /*#__PURE__*/ main.$type; 26 26 export const $assert = /*#__PURE__*/ main.assert.bind(main), 27 27 $check = /*#__PURE__*/ main.check.bind(main), 28 28 $cast = /*#__PURE__*/ main.cast.bind(main), ··· 31 31 $parse = /*#__PURE__*/ main.parse.bind(main), 32 32 $safeParse = /*#__PURE__*/ main.safeParse.bind(main), 33 33 $validate = /*#__PURE__*/ main.validate.bind(main), 34 34 - $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main) 34 34 + $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main);

+6 -6

api/src/lexicons/sh/tangled/knot.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './knot.defs.ts' 6 6 - export * as $defs from './knot.defs.ts' 7 7 - export * as listKeys from './knot/listKeys.ts' 8 8 - export * as member from './knot/member.ts' 9 9 - export * as subscribeRepos from './knot/subscribeRepos.ts' 10 10 - export * as version from './knot/version.ts' 5 5 + export * from "./knot.defs.ts"; 6 6 + export * as $defs from "./knot.defs.ts"; 7 7 + export * as listKeys from "./knot/listKeys.ts"; 8 8 + export * as member from "./knot/member.ts"; 9 9 + export * as subscribeRepos from "./knot/subscribeRepos.ts"; 10 10 + export * as version from "./knot/version.ts";

+22 -27

api/src/lexicons/sh/tangled/knot/listKeys.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.knot.listKeys' 7 7 + const $nsid = "sh.tangled.knot.listKeys"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 /** List all public keys stored in the knot server */ 12 12 const main = l.query( 13 13 $nsid, 14 14 l.params({ 15 15 - limit: l.optional( 16 16 - l.withDefault(l.integer({ minimum: 1, maximum: 1000 }), 100), 17 17 - ), 15 15 + limit: l.optional(l.withDefault(l.integer({ minimum: 1, maximum: 1000 }), 100)), 18 16 cursor: l.optional(l.string()), 19 17 }), 20 18 l.jsonPayload({ 21 19 keys: l.array(l.ref<PublicKey>((() => publicKey) as any)), 22 20 cursor: l.optional(l.string()), 23 21 }), 24 24 - ['InternalServerError'], 25 25 - ) 26 26 - export { main } 22 22 + ["InternalServerError"], 23 23 + ); 24 24 + export { main }; 27 25 28 28 - export type $Params = l.InferMethodParams<typeof main> 29 29 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 30 30 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 31 31 - typeof main, 32 32 - B 33 33 - > 26 26 + export type $Params = l.InferMethodParams<typeof main>; 27 27 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 28 28 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 34 29 35 30 export const $lxm = main.nsid, 36 31 $params = main.parameters, 37 37 - $output = main.output 32 32 + $output = main.output; 38 33 39 34 type PublicKey = { 40 40 - $type?: 'sh.tangled.knot.listKeys#publicKey' 35 35 + $type?: "sh.tangled.knot.listKeys#publicKey"; 41 36 42 37 /** 43 38 * DID associated with the public key 44 39 */ 45 45 - did: l.DidString 40 40 + did: l.DidString; 46 41 47 42 /** 48 43 * Public key contents 49 44 */ 50 50 - key: string 45 45 + key: string; 51 46 52 47 /** 53 48 * Key upload timestamp 54 49 */ 55 55 - createdAt: l.DatetimeString 56 56 - } 50 50 + createdAt: l.DatetimeString; 51 51 + }; 57 52 58 58 - export type { PublicKey } 53 53 + export type { PublicKey }; 59 54 60 55 const publicKey = l.typedObject<PublicKey>( 61 56 $nsid, 62 62 - 'publicKey', 57 57 + "publicKey", 63 58 l.object({ 64 64 - did: l.string({ format: 'did' }), 59 59 + did: l.string({ format: "did" }), 65 60 key: l.string({ maxLength: 4096 }), 66 66 - createdAt: l.string({ format: 'datetime' }), 61 61 + createdAt: l.string({ format: "datetime" }), 67 62 }), 68 68 - ) 63 63 + ); 69 64 70 70 - export { publicKey } 65 65 + export { publicKey };

+2 -2

api/src/lexicons/sh/tangled/knot/listKeys.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './listKeys.defs.ts' 6 6 - export * as $defs from './listKeys.defs.ts' 5 5 + export * from "./listKeys.defs.ts"; 6 6 + export * as $defs from "./listKeys.defs.ts";

+17 -17

api/src/lexicons/sh/tangled/knot/member.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.knot.member' 7 7 + const $nsid = "sh.tangled.knot.member"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 type Main = { 12 12 - $type: 'sh.tangled.knot.member' 13 13 - subject: l.DidString 12 12 + $type: "sh.tangled.knot.member"; 13 13 + subject: l.DidString; 14 14 15 15 /** 16 16 * domain that this member now belongs to 17 17 */ 18 18 - domain: string 19 19 - createdAt: l.DatetimeString 20 20 - } 18 18 + domain: string; 19 19 + createdAt: l.DatetimeString; 20 20 + }; 21 21 22 22 - export type { Main } 22 22 + export type { Main }; 23 23 24 24 - const main = l.record<'tid', Main>( 25 25 - 'tid', 24 24 + const main = l.record<"tid", Main>( 25 25 + "tid", 26 26 $nsid, 27 27 l.object({ 28 28 - subject: l.string({ format: 'did' }), 28 28 + subject: l.string({ format: "did" }), 29 29 domain: l.string(), 30 30 - createdAt: l.string({ format: 'datetime' }), 30 30 + createdAt: l.string({ format: "datetime" }), 31 31 }), 32 32 - ) 32 32 + ); 33 33 34 34 - export { main } 34 34 + export { main }; 35 35 36 36 export const $isTypeOf = /*#__PURE__*/ main.isTypeOf.bind(main), 37 37 $build = /*#__PURE__*/ main.build.bind(main), 38 38 - $type = /*#__PURE__*/ main.$type 38 38 + $type = /*#__PURE__*/ main.$type; 39 39 export const $assert = /*#__PURE__*/ main.assert.bind(main), 40 40 $check = /*#__PURE__*/ main.check.bind(main), 41 41 $cast = /*#__PURE__*/ main.cast.bind(main), ··· 44 44 $parse = /*#__PURE__*/ main.parse.bind(main), 45 45 $safeParse = /*#__PURE__*/ main.safeParse.bind(main), 46 46 $validate = /*#__PURE__*/ main.validate.bind(main), 47 47 - $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main) 47 47 + $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main);

+2 -2

api/src/lexicons/sh/tangled/knot/member.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './member.defs.ts' 6 6 - export * as $defs from './member.defs.ts' 5 5 + export * from "./member.defs.ts"; 6 6 + export * as $defs from "./member.defs.ts";

+39 -39

api/src/lexicons/sh/tangled/knot/subscribeRepos.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 6 6 - import * as GitRefUpdate from '../git/refUpdate.defs.ts' 5 5 + import { l } from "@atproto/lex"; 6 6 + import * as GitRefUpdate from "../git/refUpdate.defs.ts"; 7 7 8 8 - const $nsid = 'sh.tangled.knot.subscribeRepos' 8 8 + const $nsid = "sh.tangled.knot.subscribeRepos"; 9 9 10 10 - export { $nsid } 10 10 + export { $nsid }; 11 11 12 12 /** Repository event stream, aka Firehose endpoint. Outputs repo commits with diff data, and identity update events, for all repositories on the current server. See the atproto specifications for details around stream sequencing, repo versioning, CAR diff format, and more. Public and does not require auth; implemented by PDS and Relay. */ 13 13 const main = l.subscription( ··· 20 20 ], 21 21 false, 22 22 ), 23 23 - ['FutureCursor', 'ConsumerTooSlow'], 24 24 - ) 25 25 - export { main } 23 23 + ["FutureCursor", "ConsumerTooSlow"], 24 24 + ); 25 25 + export { main }; 26 26 27 27 - export type $Params = l.InferMethodParams<typeof main> 28 28 - export type $Message = l.InferSubscriptionMessage<typeof main> 27 27 + export type $Params = l.InferMethodParams<typeof main>; 28 28 + export type $Message = l.InferSubscriptionMessage<typeof main>; 29 29 30 30 export const $lxm = main.nsid, 31 31 $params = main.parameters, 32 32 - $message = main.message 32 32 + $message = main.message; 33 33 34 34 type Identity = { 35 35 - $type?: 'sh.tangled.knot.subscribeRepos#identity' 35 35 + $type?: "sh.tangled.knot.subscribeRepos#identity"; 36 36 37 37 /** 38 38 * The stream sequence number of this message. 39 39 */ 40 40 - seq: number 40 40 + seq: number; 41 41 42 42 /** 43 43 * Repository DID identifier 44 44 */ 45 45 - did: l.DidString 46 46 - time: l.DatetimeString 47 47 - } 45 45 + did: l.DidString; 46 46 + time: l.DatetimeString; 47 47 + }; 48 48 49 49 - export type { Identity } 49 49 + export type { Identity }; 50 50 51 51 const identity = l.typedObject<Identity>( 52 52 $nsid, 53 53 - 'identity', 53 53 + "identity", 54 54 l.object({ 55 55 seq: l.integer(), 56 56 - did: l.string({ format: 'did' }), 57 57 - time: l.string({ format: 'datetime' }), 56 56 + did: l.string({ format: "did" }), 57 57 + time: l.string({ format: "datetime" }), 58 58 }), 59 59 - ) 59 59 + ); 60 60 61 61 - export { identity } 61 61 + export { identity }; 62 62 63 63 type GitSync1 = { 64 64 - $type?: 'sh.tangled.knot.subscribeRepos#gitSync1' 64 64 + $type?: "sh.tangled.knot.subscribeRepos#gitSync1"; 65 65 66 66 /** 67 67 * The stream sequence number of this message. 68 68 */ 69 69 - seq: number 69 69 + seq: number; 70 70 71 71 /** 72 72 * Repository DID identifier 73 73 */ 74 74 - did: l.DidString 75 75 - } 74 74 + did: l.DidString; 75 75 + }; 76 76 77 77 - export type { GitSync1 } 77 77 + export type { GitSync1 }; 78 78 79 79 const gitSync1 = l.typedObject<GitSync1>( 80 80 $nsid, 81 81 - 'gitSync1', 82 82 - l.object({ seq: l.integer(), did: l.string({ format: 'did' }) }), 83 83 - ) 81 81 + "gitSync1", 82 82 + l.object({ seq: l.integer(), did: l.string({ format: "did" }) }), 83 83 + ); 84 84 85 85 - export { gitSync1 } 85 85 + export { gitSync1 }; 86 86 87 87 type GitSync2 = { 88 88 - $type?: 'sh.tangled.knot.subscribeRepos#gitSync2' 88 88 + $type?: "sh.tangled.knot.subscribeRepos#gitSync2"; 89 89 90 90 /** 91 91 * The stream sequence number of this message. 92 92 */ 93 93 - seq: number 93 93 + seq: number; 94 94 95 95 /** 96 96 * Repository AT-URI identifier 97 97 */ 98 98 - repo: l.AtUriString 99 99 - } 98 98 + repo: l.AtUriString; 99 99 + }; 100 100 101 101 - export type { GitSync2 } 101 101 + export type { GitSync2 }; 102 102 103 103 const gitSync2 = l.typedObject<GitSync2>( 104 104 $nsid, 105 105 - 'gitSync2', 106 106 - l.object({ seq: l.integer(), repo: l.string({ format: 'at-uri' }) }), 107 107 - ) 105 105 + "gitSync2", 106 106 + l.object({ seq: l.integer(), repo: l.string({ format: "at-uri" }) }), 107 107 + ); 108 108 109 109 - export { gitSync2 } 109 109 + export { gitSync2 };

+2 -2

api/src/lexicons/sh/tangled/knot/subscribeRepos.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './subscribeRepos.defs.ts' 6 6 - export * as $defs from './subscribeRepos.defs.ts' 5 5 + export * from "./subscribeRepos.defs.ts"; 6 6 + export * as $defs from "./subscribeRepos.defs.ts";

+9 -12

api/src/lexicons/sh/tangled/knot/version.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.knot.version' 7 7 + const $nsid = "sh.tangled.knot.version"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 /** Get the version of a knot */ 12 12 - const main = l.query($nsid, l.params(), l.jsonPayload({ version: l.string() })) 13 13 - export { main } 12 12 + const main = l.query($nsid, l.params(), l.jsonPayload({ version: l.string() })); 13 13 + export { main }; 14 14 15 15 - export type $Params = l.InferMethodParams<typeof main> 16 16 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 17 17 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 18 18 - typeof main, 19 19 - B 20 20 - > 15 15 + export type $Params = l.InferMethodParams<typeof main>; 16 16 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 17 17 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 21 18 22 19 export const $lxm = main.nsid, 23 20 $params = main.parameters, 24 24 - $output = main.output 21 21 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/knot/version.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './version.defs.ts' 6 6 - export * as $defs from './version.defs.ts' 5 5 + export * from "./version.defs.ts"; 6 6 + export * as $defs from "./version.defs.ts";

+2 -2

api/src/lexicons/sh/tangled/label.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * as definition from './label/definition.ts' 6 6 - export * as op from './label/op.ts' 5 5 + export * as definition from "./label/definition.ts"; 6 6 + export * as op from "./label/op.ts";

+31 -31

api/src/lexicons/sh/tangled/label/definition.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.label.definition' 7 7 + const $nsid = "sh.tangled.label.definition"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 type Main = { 12 12 - $type: 'sh.tangled.label.definition' 12 12 + $type: "sh.tangled.label.definition"; 13 13 14 14 /** 15 15 * The display name of this label. 16 16 */ 17 17 - name: string 17 17 + name: string; 18 18 19 19 /** 20 20 * The type definition of this label. Appviews may allow sorting for certain types. 21 21 */ 22 22 - valueType: ValueType 22 22 + valueType: ValueType; 23 23 24 24 /** 25 25 * The areas of the repo this label may apply to, eg.: sh.tangled.repo.issue. Appviews may choose to respect this. 26 26 */ 27 27 - scope: l.NsidString[] 27 27 + scope: l.NsidString[]; 28 28 29 29 /** 30 30 * The hex value for the background color for the label. Appviews may choose to respect this. 31 31 */ 32 32 - color?: string 33 33 - createdAt: l.DatetimeString 32 32 + color?: string; 33 33 + createdAt: l.DatetimeString; 34 34 35 35 /** 36 36 * Whether this label can be repeated for a given entity, eg.: [reviewer:foo, reviewer:bar] 37 37 */ 38 38 - multiple?: boolean 39 39 - } 38 38 + multiple?: boolean; 39 39 + }; 40 40 41 41 - export type { Main } 41 41 + export type { Main }; 42 42 43 43 - const main = l.record<'any', Main>( 44 44 - 'any', 43 43 + const main = l.record<"any", Main>( 44 44 + "any", 45 45 $nsid, 46 46 l.object({ 47 47 name: l.string({ minGraphemes: 1, maxGraphemes: 40 }), 48 48 valueType: l.ref<ValueType>((() => valueType) as any), 49 49 - scope: l.array(l.string({ format: 'nsid' })), 49 49 + scope: l.array(l.string({ format: "nsid" })), 50 50 color: l.optional(l.string()), 51 51 - createdAt: l.string({ format: 'datetime' }), 51 51 + createdAt: l.string({ format: "datetime" }), 52 52 multiple: l.optional(l.boolean()), 53 53 }), 54 54 - ) 54 54 + ); 55 55 56 56 - export { main } 56 56 + export { main }; 57 57 58 58 export const $isTypeOf = /*#__PURE__*/ main.isTypeOf.bind(main), 59 59 $build = /*#__PURE__*/ main.build.bind(main), 60 60 - $type = /*#__PURE__*/ main.$type 60 60 + $type = /*#__PURE__*/ main.$type; 61 61 export const $assert = /*#__PURE__*/ main.assert.bind(main), 62 62 $check = /*#__PURE__*/ main.check.bind(main), 63 63 $cast = /*#__PURE__*/ main.cast.bind(main), ··· 66 66 $parse = /*#__PURE__*/ main.parse.bind(main), 67 67 $safeParse = /*#__PURE__*/ main.safeParse.bind(main), 68 68 $validate = /*#__PURE__*/ main.validate.bind(main), 69 69 - $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main) 69 69 + $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main); 70 70 71 71 type ValueType = { 72 72 - $type?: 'sh.tangled.label.definition#valueType' 72 72 + $type?: "sh.tangled.label.definition#valueType"; 73 73 74 74 /** 75 75 * The concrete type of this label's value. 76 76 */ 77 77 - type: 'null' | 'boolean' | 'integer' | 'string' 77 77 + type: "null" | "boolean" | "integer" | "string"; 78 78 79 79 /** 80 80 * An optional constraint that can be applied on string concrete types. 81 81 */ 82 82 - format: 'any' | 'did' | 'nsid' 82 82 + format: "any" | "did" | "nsid"; 83 83 84 84 /** 85 85 * Closed set of values that this label can take. 86 86 */ 87 87 - enum?: string[] 88 88 - } 87 87 + enum?: string[]; 88 88 + }; 89 89 90 90 - export type { ValueType } 90 90 + export type { ValueType }; 91 91 92 92 const valueType = l.typedObject<ValueType>( 93 93 $nsid, 94 94 - 'valueType', 94 94 + "valueType", 95 95 l.object({ 96 96 - type: l.enum(['null', 'boolean', 'integer', 'string']), 97 97 - format: l.enum(['any', 'did', 'nsid']), 96 96 + type: l.enum(["null", "boolean", "integer", "string"]), 97 97 + format: l.enum(["any", "did", "nsid"]), 98 98 enum: l.optional(l.array(l.string())), 99 99 }), 100 100 - ) 100 100 + ); 101 101 102 102 - export { valueType } 102 102 + export { valueType };

+2 -2

api/src/lexicons/sh/tangled/label/definition.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './definition.defs.ts' 6 6 - export * as $defs from './definition.defs.ts' 5 5 + export * from "./definition.defs.ts"; 6 6 + export * as $defs from "./definition.defs.ts";

+27 -27

api/src/lexicons/sh/tangled/label/op.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.label.op' 7 7 + const $nsid = "sh.tangled.label.op"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 type Main = { 12 12 - $type: 'sh.tangled.label.op' 12 12 + $type: "sh.tangled.label.op"; 13 13 14 14 /** 15 15 * The subject (task, pull or discussion) of this label. Appviews may apply a `scope` check and refuse this op. 16 16 */ 17 17 - subject: l.AtUriString 18 18 - performedAt: l.DatetimeString 19 19 - add: Operand[] 20 20 - delete: Operand[] 21 21 - } 17 17 + subject: l.AtUriString; 18 18 + performedAt: l.DatetimeString; 19 19 + add: Operand[]; 20 20 + delete: Operand[]; 21 21 + }; 22 22 23 23 - export type { Main } 23 23 + export type { Main }; 24 24 25 25 - const main = l.record<'tid', Main>( 26 26 - 'tid', 25 25 + const main = l.record<"tid", Main>( 26 26 + "tid", 27 27 $nsid, 28 28 l.object({ 29 29 - subject: l.string({ format: 'at-uri' }), 30 30 - performedAt: l.string({ format: 'datetime' }), 29 29 + subject: l.string({ format: "at-uri" }), 30 30 + performedAt: l.string({ format: "datetime" }), 31 31 add: l.array(l.ref<Operand>((() => operand) as any)), 32 32 delete: l.array(l.ref<Operand>((() => operand) as any)), 33 33 }), 34 34 - ) 34 34 + ); 35 35 36 36 - export { main } 36 36 + export { main }; 37 37 38 38 export const $isTypeOf = /*#__PURE__*/ main.isTypeOf.bind(main), 39 39 $build = /*#__PURE__*/ main.build.bind(main), 40 40 - $type = /*#__PURE__*/ main.$type 40 40 + $type = /*#__PURE__*/ main.$type; 41 41 export const $assert = /*#__PURE__*/ main.assert.bind(main), 42 42 $check = /*#__PURE__*/ main.check.bind(main), 43 43 $cast = /*#__PURE__*/ main.cast.bind(main), ··· 46 46 $parse = /*#__PURE__*/ main.parse.bind(main), 47 47 $safeParse = /*#__PURE__*/ main.safeParse.bind(main), 48 48 $validate = /*#__PURE__*/ main.validate.bind(main), 49 49 - $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main) 49 49 + $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main); 50 50 51 51 type Operand = { 52 52 - $type?: 'sh.tangled.label.op#operand' 52 52 + $type?: "sh.tangled.label.op#operand"; 53 53 54 54 /** 55 55 * ATURI to the label definition 56 56 */ 57 57 - key: l.AtUriString 57 57 + key: l.AtUriString; 58 58 59 59 /** 60 60 * Stringified value of the label. This is first unstringed by appviews and then interpreted as a concrete value. 61 61 */ 62 62 - value: string 63 63 - } 62 62 + value: string; 63 63 + }; 64 64 65 65 - export type { Operand } 65 65 + export type { Operand }; 66 66 67 67 const operand = l.typedObject<Operand>( 68 68 $nsid, 69 69 - 'operand', 70 70 - l.object({ key: l.string({ format: 'at-uri' }), value: l.string() }), 71 71 - ) 69 69 + "operand", 70 70 + l.object({ key: l.string({ format: "at-uri" }), value: l.string() }), 71 71 + ); 72 72 73 73 - export { operand } 73 73 + export { operand };

+2 -2

api/src/lexicons/sh/tangled/label/op.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './op.defs.ts' 6 6 - export * as $defs from './op.defs.ts' 5 5 + export * from "./op.defs.ts"; 6 6 + export * as $defs from "./op.defs.ts";

+11 -17

api/src/lexicons/sh/tangled/owner.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.owner' 7 7 + const $nsid = "sh.tangled.owner"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 /** Get the owner of a service */ 12 12 - const main = l.query( 13 13 - $nsid, 14 14 - l.params(), 15 15 - l.jsonPayload({ owner: l.string({ format: 'did' }) }), 16 16 - ['OwnerNotFound'], 17 17 - ) 18 18 - export { main } 12 12 + const main = l.query($nsid, l.params(), l.jsonPayload({ owner: l.string({ format: "did" }) }), [ 13 13 + "OwnerNotFound", 14 14 + ]); 15 15 + export { main }; 19 16 20 20 - export type $Params = l.InferMethodParams<typeof main> 21 21 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 22 22 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 23 23 - typeof main, 24 24 - B 25 25 - > 17 17 + export type $Params = l.InferMethodParams<typeof main>; 18 18 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 19 19 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 26 20 27 21 export const $lxm = main.nsid, 28 22 $params = main.parameters, 29 29 - $output = main.output 23 23 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/owner.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './owner.defs.ts' 6 6 - export * as $defs from './owner.defs.ts' 5 5 + export * from "./owner.defs.ts"; 6 6 + export * as $defs from "./owner.defs.ts";

+90 -98

api/src/lexicons/sh/tangled/pipeline.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.pipeline' 7 7 + const $nsid = "sh.tangled.pipeline"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 type Main = { 12 12 - $type: 'sh.tangled.pipeline' 13 13 - triggerMetadata: TriggerMetadata 14 14 - workflows: Workflow[] 15 15 - } 12 12 + $type: "sh.tangled.pipeline"; 13 13 + triggerMetadata: TriggerMetadata; 14 14 + workflows: Workflow[]; 15 15 + }; 16 16 17 17 - export type { Main } 17 17 + export type { Main }; 18 18 19 19 - const main = l.record<'tid', Main>( 20 20 - 'tid', 19 19 + const main = l.record<"tid", Main>( 20 20 + "tid", 21 21 $nsid, 22 22 l.object({ 23 23 triggerMetadata: l.ref<TriggerMetadata>((() => triggerMetadata) as any), 24 24 workflows: l.array(l.ref<Workflow>((() => workflow) as any)), 25 25 }), 26 26 - ) 26 26 + ); 27 27 28 28 - export { main } 28 28 + export { main }; 29 29 30 30 export const $isTypeOf = /*#__PURE__*/ main.isTypeOf.bind(main), 31 31 $build = /*#__PURE__*/ main.build.bind(main), 32 32 - $type = /*#__PURE__*/ main.$type 32 32 + $type = /*#__PURE__*/ main.$type; 33 33 export const $assert = /*#__PURE__*/ main.assert.bind(main), 34 34 $check = /*#__PURE__*/ main.check.bind(main), 35 35 $cast = /*#__PURE__*/ main.cast.bind(main), ··· 38 38 $parse = /*#__PURE__*/ main.parse.bind(main), 39 39 $safeParse = /*#__PURE__*/ main.safeParse.bind(main), 40 40 $validate = /*#__PURE__*/ main.validate.bind(main), 41 41 - $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main) 41 41 + $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main); 42 42 43 43 type TriggerMetadata = { 44 44 - $type?: 'sh.tangled.pipeline#triggerMetadata' 45 45 - kind: 'push' | 'pull_request' | 'manual' 46 46 - repo: TriggerRepo 47 47 - push?: PushTriggerData 48 48 - pullRequest?: PullRequestTriggerData 49 49 - manual?: ManualTriggerData 50 50 - } 44 44 + $type?: "sh.tangled.pipeline#triggerMetadata"; 45 45 + kind: "push" | "pull_request" | "manual"; 46 46 + repo: TriggerRepo; 47 47 + push?: PushTriggerData; 48 48 + pullRequest?: PullRequestTriggerData; 49 49 + manual?: ManualTriggerData; 50 50 + }; 51 51 52 52 - export type { TriggerMetadata } 52 52 + export type { TriggerMetadata }; 53 53 54 54 const triggerMetadata = l.typedObject<TriggerMetadata>( 55 55 $nsid, 56 56 - 'triggerMetadata', 56 56 + "triggerMetadata", 57 57 l.object({ 58 58 - kind: l.enum(['push', 'pull_request', 'manual']), 58 58 + kind: l.enum(["push", "pull_request", "manual"]), 59 59 repo: l.ref<TriggerRepo>((() => triggerRepo) as any), 60 60 push: l.optional(l.ref<PushTriggerData>((() => pushTriggerData) as any)), 61 61 - pullRequest: l.optional( 62 62 - l.ref<PullRequestTriggerData>((() => pullRequestTriggerData) as any), 63 63 - ), 64 64 - manual: l.optional( 65 65 - l.ref<ManualTriggerData>((() => manualTriggerData) as any), 66 66 - ), 61 61 + pullRequest: l.optional(l.ref<PullRequestTriggerData>((() => pullRequestTriggerData) as any)), 62 62 + manual: l.optional(l.ref<ManualTriggerData>((() => manualTriggerData) as any)), 67 63 }), 68 68 - ) 64 64 + ); 69 65 70 70 - export { triggerMetadata } 66 66 + export { triggerMetadata }; 71 67 72 68 type TriggerRepo = { 73 73 - $type?: 'sh.tangled.pipeline#triggerRepo' 74 74 - knot: string 75 75 - did: l.DidString 69 69 + $type?: "sh.tangled.pipeline#triggerRepo"; 70 70 + knot: string; 71 71 + did: l.DidString; 76 72 77 73 /** 78 74 * DID of the repo itself 79 75 */ 80 80 - repoDid?: l.DidString 81 81 - repo?: string 82 82 - defaultBranch: string 83 83 - } 76 76 + repoDid?: l.DidString; 77 77 + repo?: string; 78 78 + defaultBranch: string; 79 79 + }; 84 80 85 85 - export type { TriggerRepo } 81 81 + export type { TriggerRepo }; 86 82 87 83 const triggerRepo = l.typedObject<TriggerRepo>( 88 84 $nsid, 89 89 - 'triggerRepo', 85 85 + "triggerRepo", 90 86 l.object({ 91 87 knot: l.string(), 92 92 - did: l.string({ format: 'did' }), 93 93 - repoDid: l.optional(l.string({ format: 'did' })), 88 88 + did: l.string({ format: "did" }), 89 89 + repoDid: l.optional(l.string({ format: "did" })), 94 90 repo: l.optional(l.string()), 95 91 defaultBranch: l.string(), 96 92 }), 97 97 - ) 93 93 + ); 98 94 99 99 - export { triggerRepo } 95 95 + export { triggerRepo }; 100 96 101 97 type PushTriggerData = { 102 102 - $type?: 'sh.tangled.pipeline#pushTriggerData' 103 103 - ref: string 104 104 - newSha: string 105 105 - oldSha: string 106 106 - } 98 98 + $type?: "sh.tangled.pipeline#pushTriggerData"; 99 99 + ref: string; 100 100 + newSha: string; 101 101 + oldSha: string; 102 102 + }; 107 103 108 108 - export type { PushTriggerData } 104 104 + export type { PushTriggerData }; 109 105 110 106 const pushTriggerData = l.typedObject<PushTriggerData>( 111 107 $nsid, 112 112 - 'pushTriggerData', 108 108 + "pushTriggerData", 113 109 l.object({ 114 110 ref: l.string(), 115 111 newSha: l.string({ minLength: 40, maxLength: 40 }), 116 112 oldSha: l.string({ minLength: 40, maxLength: 40 }), 117 113 }), 118 118 - ) 114 114 + ); 119 115 120 120 - export { pushTriggerData } 116 116 + export { pushTriggerData }; 121 117 122 118 type PullRequestTriggerData = { 123 123 - $type?: 'sh.tangled.pipeline#pullRequestTriggerData' 124 124 - sourceBranch: string 125 125 - targetBranch: string 126 126 - sourceSha: string 127 127 - action: string 128 128 - } 119 119 + $type?: "sh.tangled.pipeline#pullRequestTriggerData"; 120 120 + sourceBranch: string; 121 121 + targetBranch: string; 122 122 + sourceSha: string; 123 123 + action: string; 124 124 + }; 129 125 130 130 - export type { PullRequestTriggerData } 126 126 + export type { PullRequestTriggerData }; 131 127 132 128 const pullRequestTriggerData = l.typedObject<PullRequestTriggerData>( 133 129 $nsid, 134 134 - 'pullRequestTriggerData', 130 130 + "pullRequestTriggerData", 135 131 l.object({ 136 132 sourceBranch: l.string(), 137 133 targetBranch: l.string(), 138 134 sourceSha: l.string({ minLength: 40, maxLength: 40 }), 139 135 action: l.string(), 140 136 }), 141 141 - ) 137 137 + ); 142 138 143 143 - export { pullRequestTriggerData } 139 139 + export { pullRequestTriggerData }; 144 140 145 141 type ManualTriggerData = { 146 146 - $type?: 'sh.tangled.pipeline#manualTriggerData' 147 147 - inputs?: Pair[] 148 148 - } 142 142 + $type?: "sh.tangled.pipeline#manualTriggerData"; 143 143 + inputs?: Pair[]; 144 144 + }; 149 145 150 150 - export type { ManualTriggerData } 146 146 + export type { ManualTriggerData }; 151 147 152 148 const manualTriggerData = l.typedObject<ManualTriggerData>( 153 149 $nsid, 154 154 - 'manualTriggerData', 150 150 + "manualTriggerData", 155 151 l.object({ inputs: l.optional(l.array(l.ref<Pair>((() => pair) as any))) }), 156 156 - ) 152 152 + ); 157 153 158 158 - export { manualTriggerData } 154 154 + export { manualTriggerData }; 159 155 160 156 type Workflow = { 161 161 - $type?: 'sh.tangled.pipeline#workflow' 162 162 - name: string 163 163 - engine: string 164 164 - clone: CloneOpts 165 165 - raw: string 166 166 - } 157 157 + $type?: "sh.tangled.pipeline#workflow"; 158 158 + name: string; 159 159 + engine: string; 160 160 + clone: CloneOpts; 161 161 + raw: string; 162 162 + }; 167 163 168 168 - export type { Workflow } 164 164 + export type { Workflow }; 169 165 170 166 const workflow = l.typedObject<Workflow>( 171 167 $nsid, 172 172 - 'workflow', 168 168 + "workflow", 173 169 l.object({ 174 170 name: l.string(), 175 171 engine: l.string(), 176 172 clone: l.ref<CloneOpts>((() => cloneOpts) as any), 177 173 raw: l.string(), 178 174 }), 179 179 - ) 175 175 + ); 180 176 181 181 - export { workflow } 177 177 + export { workflow }; 182 178 183 179 type CloneOpts = { 184 184 - $type?: 'sh.tangled.pipeline#cloneOpts' 185 185 - skip: boolean 186 186 - depth: number 187 187 - submodules: boolean 188 188 - } 180 180 + $type?: "sh.tangled.pipeline#cloneOpts"; 181 181 + skip: boolean; 182 182 + depth: number; 183 183 + submodules: boolean; 184 184 + }; 189 185 190 190 - export type { CloneOpts } 186 186 + export type { CloneOpts }; 191 187 192 188 const cloneOpts = l.typedObject<CloneOpts>( 193 189 $nsid, 194 194 - 'cloneOpts', 190 190 + "cloneOpts", 195 191 l.object({ skip: l.boolean(), depth: l.integer(), submodules: l.boolean() }), 196 196 - ) 192 192 + ); 197 193 198 198 - export { cloneOpts } 194 194 + export { cloneOpts }; 199 195 200 200 - type Pair = { $type?: 'sh.tangled.pipeline#pair'; key: string; value: string } 196 196 + type Pair = { $type?: "sh.tangled.pipeline#pair"; key: string; value: string }; 201 197 202 202 - export type { Pair } 198 198 + export type { Pair }; 203 199 204 204 - const pair = l.typedObject<Pair>( 205 205 - $nsid, 206 206 - 'pair', 207 207 - l.object({ key: l.string(), value: l.string() }), 208 208 - ) 200 200 + const pair = l.typedObject<Pair>($nsid, "pair", l.object({ key: l.string(), value: l.string() })); 209 201 210 210 - export { pair } 202 202 + export { pair };

+4 -4

api/src/lexicons/sh/tangled/pipeline.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * as cancelPipeline from './pipeline/cancelPipeline.ts' 6 6 - export * from './pipeline.defs.ts' 7 7 - export * as $defs from './pipeline.defs.ts' 8 8 - export * as status from './pipeline/status.ts' 5 5 + export * as cancelPipeline from "./pipeline/cancelPipeline.ts"; 6 6 + export * from "./pipeline.defs.ts"; 7 7 + export * as $defs from "./pipeline.defs.ts"; 8 8 + export * as status from "./pipeline/status.ts";

+13 -19

api/src/lexicons/sh/tangled/pipeline/cancelPipeline.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.pipeline.cancelPipeline' 7 7 + const $nsid = "sh.tangled.pipeline.cancelPipeline"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 /** Cancel a running pipeline */ 12 12 const main = l.procedure( 13 13 $nsid, 14 14 l.params(), 15 15 l.jsonPayload({ 16 16 - repo: l.string({ format: 'at-uri' }), 17 17 - pipeline: l.string({ format: 'at-uri' }), 16 16 + repo: l.string({ format: "at-uri" }), 17 17 + pipeline: l.string({ format: "at-uri" }), 18 18 workflow: l.string(), 19 19 }), 20 20 l.payload(), 21 21 - ) 22 22 - export { main } 21 21 + ); 22 22 + export { main }; 23 23 24 24 - export type $Params = l.InferMethodParams<typeof main> 25 25 - export type $Input<B = l.BinaryData> = l.InferMethodInput<typeof main, B> 26 26 - export type $InputBody<B = l.BinaryData> = l.InferMethodInputBody< 27 27 - typeof main, 28 28 - B 29 29 - > 30 30 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 31 31 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 32 32 - typeof main, 33 33 - B 34 34 - > 24 24 + export type $Params = l.InferMethodParams<typeof main>; 25 25 + export type $Input<B = l.BinaryData> = l.InferMethodInput<typeof main, B>; 26 26 + export type $InputBody<B = l.BinaryData> = l.InferMethodInputBody<typeof main, B>; 27 27 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 28 28 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 35 29 36 30 export const $lxm = main.nsid, 37 31 $params = main.parameters, 38 32 $input = main.input, 39 39 - $output = main.output 33 33 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/pipeline/cancelPipeline.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './cancelPipeline.defs.ts' 6 6 - export * as $defs from './cancelPipeline.defs.ts' 5 5 + export * from "./cancelPipeline.defs.ts"; 6 6 + export * as $defs from "./cancelPipeline.defs.ts";

+22 -29

api/src/lexicons/sh/tangled/pipeline/status.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.pipeline.status' 7 7 + const $nsid = "sh.tangled.pipeline.status"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 type Main = { 12 12 - $type: 'sh.tangled.pipeline.status' 12 12 + $type: "sh.tangled.pipeline.status"; 13 13 14 14 /** 15 15 * ATURI of the pipeline 16 16 */ 17 17 - pipeline: l.AtUriString 17 17 + pipeline: l.AtUriString; 18 18 19 19 /** 20 20 * name of the workflow within this pipeline 21 21 */ 22 22 - workflow: l.AtUriString 22 22 + workflow: l.AtUriString; 23 23 24 24 /** 25 25 * status of the workflow 26 26 */ 27 27 - status: 'pending' | 'running' | 'failed' | 'timeout' | 'cancelled' | 'success' 27 27 + status: "pending" | "running" | "failed" | "timeout" | "cancelled" | "success"; 28 28 29 29 /** 30 30 * time of creation of this status update 31 31 */ 32 32 - createdAt: l.DatetimeString 32 32 + createdAt: l.DatetimeString; 33 33 34 34 /** 35 35 * error message if failed 36 36 */ 37 37 - error?: string 37 37 + error?: string; 38 38 39 39 /** 40 40 * exit code if failed 41 41 */ 42 42 - exitCode?: number 43 43 - } 42 42 + exitCode?: number; 43 43 + }; 44 44 45 45 - export type { Main } 45 45 + export type { Main }; 46 46 47 47 - const main = l.record<'tid', Main>( 48 48 - 'tid', 47 47 + const main = l.record<"tid", Main>( 48 48 + "tid", 49 49 $nsid, 50 50 l.object({ 51 51 - pipeline: l.string({ format: 'at-uri' }), 52 52 - workflow: l.string({ format: 'at-uri' }), 53 53 - status: l.enum([ 54 54 - 'pending', 55 55 - 'running', 56 56 - 'failed', 57 57 - 'timeout', 58 58 - 'cancelled', 59 59 - 'success', 60 60 - ]), 61 61 - createdAt: l.string({ format: 'datetime' }), 51 51 + pipeline: l.string({ format: "at-uri" }), 52 52 + workflow: l.string({ format: "at-uri" }), 53 53 + status: l.enum(["pending", "running", "failed", "timeout", "cancelled", "success"]), 54 54 + createdAt: l.string({ format: "datetime" }), 62 55 error: l.optional(l.string()), 63 56 exitCode: l.optional(l.integer()), 64 57 }), 65 65 - ) 58 58 + ); 66 59 67 67 - export { main } 60 60 + export { main }; 68 61 69 62 export const $isTypeOf = /*#__PURE__*/ main.isTypeOf.bind(main), 70 63 $build = /*#__PURE__*/ main.build.bind(main), 71 71 - $type = /*#__PURE__*/ main.$type 64 64 + $type = /*#__PURE__*/ main.$type; 72 65 export const $assert = /*#__PURE__*/ main.assert.bind(main), 73 66 $check = /*#__PURE__*/ main.check.bind(main), 74 67 $cast = /*#__PURE__*/ main.cast.bind(main), ··· 77 70 $parse = /*#__PURE__*/ main.parse.bind(main), 78 71 $safeParse = /*#__PURE__*/ main.safeParse.bind(main), 79 72 $validate = /*#__PURE__*/ main.validate.bind(main), 80 80 - $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main) 73 73 + $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main);

+2 -2

api/src/lexicons/sh/tangled/pipeline/status.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './status.defs.ts' 6 6 - export * as $defs from './status.defs.ts' 5 5 + export * from "./status.defs.ts"; 6 6 + export * as $defs from "./status.defs.ts";

+16 -16

api/src/lexicons/sh/tangled/publicKey.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.publicKey' 7 7 + const $nsid = "sh.tangled.publicKey"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 type Main = { 12 12 - $type: 'sh.tangled.publicKey' 12 12 + $type: "sh.tangled.publicKey"; 13 13 14 14 /** 15 15 * public key contents 16 16 */ 17 17 - key: string 17 17 + key: string; 18 18 19 19 /** 20 20 * human-readable name for this key 21 21 */ 22 22 - name: string 22 22 + name: string; 23 23 24 24 /** 25 25 * key upload timestamp 26 26 */ 27 27 - createdAt: l.DatetimeString 28 28 - } 27 27 + createdAt: l.DatetimeString; 28 28 + }; 29 29 30 30 - export type { Main } 30 30 + export type { Main }; 31 31 32 32 - const main = l.record<'tid', Main>( 33 33 - 'tid', 32 32 + const main = l.record<"tid", Main>( 33 33 + "tid", 34 34 $nsid, 35 35 l.object({ 36 36 key: l.string({ maxLength: 4096 }), 37 37 name: l.string(), 38 38 - createdAt: l.string({ format: 'datetime' }), 38 38 + createdAt: l.string({ format: "datetime" }), 39 39 }), 40 40 - ) 40 40 + ); 41 41 42 42 - export { main } 42 42 + export { main }; 43 43 44 44 export const $isTypeOf = /*#__PURE__*/ main.isTypeOf.bind(main), 45 45 $build = /*#__PURE__*/ main.build.bind(main), 46 46 - $type = /*#__PURE__*/ main.$type 46 46 + $type = /*#__PURE__*/ main.$type; 47 47 export const $assert = /*#__PURE__*/ main.assert.bind(main), 48 48 $check = /*#__PURE__*/ main.check.bind(main), 49 49 $cast = /*#__PURE__*/ main.cast.bind(main), ··· 52 52 $parse = /*#__PURE__*/ main.parse.bind(main), 53 53 $safeParse = /*#__PURE__*/ main.safeParse.bind(main), 54 54 $validate = /*#__PURE__*/ main.validate.bind(main), 55 55 - $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main) 55 55 + $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main);

+2 -2

api/src/lexicons/sh/tangled/publicKey.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './publicKey.defs.ts' 6 6 - export * as $defs from './publicKey.defs.ts' 5 5 + export * from "./publicKey.defs.ts"; 6 6 + export * as $defs from "./publicKey.defs.ts";

+28 -30

api/src/lexicons/sh/tangled/repo.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo' 7 7 + const $nsid = "sh.tangled.repo"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 type Main = { 12 12 - $type: 'sh.tangled.repo' 12 12 + $type: "sh.tangled.repo"; 13 13 14 14 /** 15 15 * name of the repo 16 16 */ 17 17 - name: string 17 17 + name: string; 18 18 19 19 /** 20 20 * knot where the repo was created 21 21 */ 22 22 - knot: string 22 22 + knot: string; 23 23 24 24 /** 25 25 * CI runner to send jobs to and receive results from 26 26 */ 27 27 - spindle?: string 28 28 - description?: string 27 27 + spindle?: string; 28 28 + description?: string; 29 29 30 30 /** 31 31 * Any URI related to the repo 32 32 */ 33 33 - website?: l.UriString 33 33 + website?: l.UriString; 34 34 35 35 /** 36 36 * Topics related to the repo 37 37 */ 38 38 - topics?: string[] 38 38 + topics?: string[]; 39 39 40 40 /** 41 41 * source of the repo 42 42 */ 43 43 - source?: l.UriString 43 43 + source?: l.UriString; 44 44 45 45 /** 46 46 * List of labels that this repo subscribes to 47 47 */ 48 48 - labels?: l.AtUriString[] 48 48 + labels?: l.AtUriString[]; 49 49 50 50 /** 51 51 * DID of the repo itself, if assigned 52 52 */ 53 53 - repoDid?: l.DidString 54 54 - createdAt: l.DatetimeString 55 55 - } 53 53 + repoDid?: l.DidString; 54 54 + createdAt: l.DatetimeString; 55 55 + }; 56 56 57 57 - export type { Main } 57 57 + export type { Main }; 58 58 59 59 - const main = l.record<'tid', Main>( 60 60 - 'tid', 59 59 + const main = l.record<"tid", Main>( 60 60 + "tid", 61 61 $nsid, 62 62 l.object({ 63 63 name: l.string(), 64 64 knot: l.string(), 65 65 spindle: l.optional(l.string()), 66 66 description: l.optional(l.string({ minGraphemes: 1, maxGraphemes: 140 })), 67 67 - website: l.optional(l.string({ format: 'uri' })), 68 68 - topics: l.optional( 69 69 - l.array(l.string({ minLength: 1, maxLength: 50 }), { maxLength: 50 }), 70 70 - ), 71 71 - source: l.optional(l.string({ format: 'uri' })), 72 72 - labels: l.optional(l.array(l.string({ format: 'at-uri' }))), 73 73 - repoDid: l.optional(l.string({ format: 'did' })), 74 74 - createdAt: l.string({ format: 'datetime' }), 67 67 + website: l.optional(l.string({ format: "uri" })), 68 68 + topics: l.optional(l.array(l.string({ minLength: 1, maxLength: 50 }), { maxLength: 50 })), 69 69 + source: l.optional(l.string({ format: "uri" })), 70 70 + labels: l.optional(l.array(l.string({ format: "at-uri" }))), 71 71 + repoDid: l.optional(l.string({ format: "did" })), 72 72 + createdAt: l.string({ format: "datetime" }), 75 73 }), 76 76 - ) 74 74 + ); 77 75 78 78 - export { main } 76 76 + export { main }; 79 77 80 78 export const $isTypeOf = /*#__PURE__*/ main.isTypeOf.bind(main), 81 79 $build = /*#__PURE__*/ main.build.bind(main), 82 82 - $type = /*#__PURE__*/ main.$type 80 80 + $type = /*#__PURE__*/ main.$type; 83 81 export const $assert = /*#__PURE__*/ main.assert.bind(main), 84 82 $check = /*#__PURE__*/ main.check.bind(main), 85 83 $cast = /*#__PURE__*/ main.cast.bind(main), ··· 88 86 $parse = /*#__PURE__*/ main.parse.bind(main), 89 87 $safeParse = /*#__PURE__*/ main.safeParse.bind(main), 90 88 $validate = /*#__PURE__*/ main.validate.bind(main), 91 91 - $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main) 89 89 + $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main);

+30 -30

api/src/lexicons/sh/tangled/repo.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * as issue from './repo/issue.ts' 6 6 - export * as pull from './repo/pull.ts' 7 7 - export * as addSecret from './repo/addSecret.ts' 8 8 - export * as archive from './repo/archive.ts' 9 9 - export * as artifact from './repo/artifact.ts' 10 10 - export * as blob from './repo/blob.ts' 11 11 - export * as branch from './repo/branch.ts' 12 12 - export * as branches from './repo/branches.ts' 13 13 - export * as collaborator from './repo/collaborator.ts' 14 14 - export * as compare from './repo/compare.ts' 15 15 - export * as create from './repo/create.ts' 16 16 - export * as setDefaultBranch from './repo/setDefaultBranch.ts' 17 17 - export * as 'delete' from './repo/delete.ts' 18 18 - export * as deleteBranch from './repo/deleteBranch.ts' 19 19 - export * as diff from './repo/diff.ts' 20 20 - export * as forkStatus from './repo/forkStatus.ts' 21 21 - export * as forkSync from './repo/forkSync.ts' 22 22 - export * as getDefaultBranch from './repo/getDefaultBranch.ts' 23 23 - export * as hiddenRef from './repo/hiddenRef.ts' 24 24 - export * as languages from './repo/languages.ts' 25 25 - export * as listSecrets from './repo/listSecrets.ts' 26 26 - export * as log from './repo/log.ts' 27 27 - export * as merge from './repo/merge.ts' 28 28 - export * as mergeCheck from './repo/mergeCheck.ts' 29 29 - export * as removeSecret from './repo/removeSecret.ts' 30 30 - export * from './repo.defs.ts' 31 31 - export * as $defs from './repo.defs.ts' 32 32 - export * as tag from './repo/tag.ts' 33 33 - export * as tags from './repo/tags.ts' 34 34 - export * as tree from './repo/tree.ts' 5 5 + export * as issue from "./repo/issue.ts"; 6 6 + export * as pull from "./repo/pull.ts"; 7 7 + export * as addSecret from "./repo/addSecret.ts"; 8 8 + export * as archive from "./repo/archive.ts"; 9 9 + export * as artifact from "./repo/artifact.ts"; 10 10 + export * as blob from "./repo/blob.ts"; 11 11 + export * as branch from "./repo/branch.ts"; 12 12 + export * as branches from "./repo/branches.ts"; 13 13 + export * as collaborator from "./repo/collaborator.ts"; 14 14 + export * as compare from "./repo/compare.ts"; 15 15 + export * as create from "./repo/create.ts"; 16 16 + export * as setDefaultBranch from "./repo/setDefaultBranch.ts"; 17 17 + export * as "delete" from "./repo/delete.ts"; 18 18 + export * as deleteBranch from "./repo/deleteBranch.ts"; 19 19 + export * as diff from "./repo/diff.ts"; 20 20 + export * as forkStatus from "./repo/forkStatus.ts"; 21 21 + export * as forkSync from "./repo/forkSync.ts"; 22 22 + export * as getDefaultBranch from "./repo/getDefaultBranch.ts"; 23 23 + export * as hiddenRef from "./repo/hiddenRef.ts"; 24 24 + export * as languages from "./repo/languages.ts"; 25 25 + export * as listSecrets from "./repo/listSecrets.ts"; 26 26 + export * as log from "./repo/log.ts"; 27 27 + export * as merge from "./repo/merge.ts"; 28 28 + export * as mergeCheck from "./repo/mergeCheck.ts"; 29 29 + export * as removeSecret from "./repo/removeSecret.ts"; 30 30 + export * from "./repo.defs.ts"; 31 31 + export * as $defs from "./repo.defs.ts"; 32 32 + export * as tag from "./repo/tag.ts"; 33 33 + export * as tags from "./repo/tags.ts"; 34 34 + export * as tree from "./repo/tree.ts";

+12 -18

api/src/lexicons/sh/tangled/repo/addSecret.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.addSecret' 7 7 + const $nsid = "sh.tangled.repo.addSecret"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 /** Add a CI secret */ 12 12 const main = l.procedure( 13 13 $nsid, 14 14 l.params(), 15 15 l.jsonPayload({ 16 16 - repo: l.string({ format: 'at-uri' }), 16 16 + repo: l.string({ format: "at-uri" }), 17 17 key: l.string({ maxLength: 50, minLength: 1 }), 18 18 value: l.string({ maxLength: 200, minLength: 1 }), 19 19 }), 20 20 l.payload(), 21 21 - ) 22 22 - export { main } 21 21 + ); 22 22 + export { main }; 23 23 24 24 - export type $Params = l.InferMethodParams<typeof main> 25 25 - export type $Input<B = l.BinaryData> = l.InferMethodInput<typeof main, B> 26 26 - export type $InputBody<B = l.BinaryData> = l.InferMethodInputBody< 27 27 - typeof main, 28 28 - B 29 29 - > 30 30 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 31 31 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 32 32 - typeof main, 33 33 - B 34 34 - > 24 24 + export type $Params = l.InferMethodParams<typeof main>; 25 25 + export type $Input<B = l.BinaryData> = l.InferMethodInput<typeof main, B>; 26 26 + export type $InputBody<B = l.BinaryData> = l.InferMethodInputBody<typeof main, B>; 27 27 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 28 28 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 35 29 36 30 export const $lxm = main.nsid, 37 31 $params = main.parameters, 38 32 $input = main.input, 39 39 - $output = main.output 33 33 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/repo/addSecret.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './addSecret.defs.ts' 6 6 - export * as $defs from './addSecret.defs.ts' 5 5 + export * from "./addSecret.defs.ts"; 6 6 + export * as $defs from "./addSecret.defs.ts";

+12 -18

api/src/lexicons/sh/tangled/repo/archive.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.archive' 7 7 + const $nsid = "sh.tangled.repo.archive"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 const main = l.query( 12 12 $nsid, ··· 14 14 repo: l.string(), 15 15 ref: l.string(), 16 16 format: l.optional( 17 17 - l.withDefault( 18 18 - l.enum(['tar', 'zip', 'tar.gz', 'tar.bz2', 'tar.xz']), 19 19 - 'tar.gz', 20 20 - ), 17 17 + l.withDefault(l.enum(["tar", "zip", "tar.gz", "tar.bz2", "tar.xz"]), "tar.gz"), 21 18 ), 22 19 prefix: l.optional(l.string()), 23 20 }), 24 24 - l.payload('*/*'), 25 25 - ['RepoNotFound', 'RefNotFound', 'InvalidRequest', 'ArchiveError'], 26 26 - ) 27 27 - export { main } 21 21 + l.payload("*/*"), 22 22 + ["RepoNotFound", "RefNotFound", "InvalidRequest", "ArchiveError"], 23 23 + ); 24 24 + export { main }; 28 25 29 29 - export type $Params = l.InferMethodParams<typeof main> 26 26 + export type $Params = l.InferMethodParams<typeof main>; 30 27 /** Binary archive data */ 31 31 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 28 28 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 32 29 /** Binary archive data */ 33 33 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 34 34 - typeof main, 35 35 - B 36 36 - > 30 30 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 37 31 38 32 export const $lxm = main.nsid, 39 33 $params = main.parameters, 40 40 - $output = main.output 34 34 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/repo/archive.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './archive.defs.ts' 6 6 - export * as $defs from './archive.defs.ts' 5 5 + export * from "./archive.defs.ts"; 6 6 + export * as $defs from "./archive.defs.ts";

+22 -22

api/src/lexicons/sh/tangled/repo/artifact.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.artifact' 7 7 + const $nsid = "sh.tangled.repo.artifact"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 type Main = { 12 12 - $type: 'sh.tangled.repo.artifact' 12 12 + $type: "sh.tangled.repo.artifact"; 13 13 14 14 /** 15 15 * name of the artifact 16 16 */ 17 17 - name: string 17 17 + name: string; 18 18 19 19 /** 20 20 * repo that this artifact is being uploaded to 21 21 */ 22 22 - repo?: l.AtUriString 23 23 - repoDid?: l.DidString 22 22 + repo?: l.AtUriString; 23 23 + repoDid?: l.DidString; 24 24 25 25 /** 26 26 * hash of the tag object that this artifact is attached to (only annotated tags are supported) 27 27 */ 28 28 - tag: Uint8Array 28 28 + tag: Uint8Array; 29 29 30 30 /** 31 31 * time of creation of this artifact 32 32 */ 33 33 - createdAt: l.DatetimeString 33 33 + createdAt: l.DatetimeString; 34 34 35 35 /** 36 36 * the artifact 37 37 */ 38 38 - artifact: l.BlobRef 39 39 - } 38 38 + artifact: l.BlobRef; 39 39 + }; 40 40 41 41 - export type { Main } 41 41 + export type { Main }; 42 42 43 43 - const main = l.record<'tid', Main>( 44 44 - 'tid', 43 43 + const main = l.record<"tid", Main>( 44 44 + "tid", 45 45 $nsid, 46 46 l.object({ 47 47 name: l.string(), 48 48 - repo: l.optional(l.string({ format: 'at-uri' })), 49 49 - repoDid: l.optional(l.string({ format: 'did' })), 48 48 + repo: l.optional(l.string({ format: "at-uri" })), 49 49 + repoDid: l.optional(l.string({ format: "did" })), 50 50 tag: l.bytes({ minLength: 20, maxLength: 20 }), 51 51 - createdAt: l.string({ format: 'datetime' }), 52 52 - artifact: l.blob({ accept: ['*/*'], maxSize: 52428800 }), 51 51 + createdAt: l.string({ format: "datetime" }), 52 52 + artifact: l.blob({ accept: ["*/*"], maxSize: 52428800 }), 53 53 }), 54 54 - ) 54 54 + ); 55 55 56 56 - export { main } 56 56 + export { main }; 57 57 58 58 export const $isTypeOf = /*#__PURE__*/ main.isTypeOf.bind(main), 59 59 $build = /*#__PURE__*/ main.build.bind(main), 60 60 - $type = /*#__PURE__*/ main.$type 60 60 + $type = /*#__PURE__*/ main.$type; 61 61 export const $assert = /*#__PURE__*/ main.assert.bind(main), 62 62 $check = /*#__PURE__*/ main.check.bind(main), 63 63 $cast = /*#__PURE__*/ main.cast.bind(main), ··· 66 66 $parse = /*#__PURE__*/ main.parse.bind(main), 67 67 $safeParse = /*#__PURE__*/ main.safeParse.bind(main), 68 68 $validate = /*#__PURE__*/ main.validate.bind(main), 69 69 - $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main) 69 69 + $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main);

+2 -2

api/src/lexicons/sh/tangled/repo/artifact.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './artifact.defs.ts' 6 6 - export * as $defs from './artifact.defs.ts' 5 5 + export * from "./artifact.defs.ts"; 6 6 + export * as $defs from "./artifact.defs.ts";

+41 -44

api/src/lexicons/sh/tangled/repo/blob.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.blob' 7 7 + const $nsid = "sh.tangled.repo.blob"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 const main = l.query( 12 12 $nsid, ··· 20 20 ref: l.string(), 21 21 path: l.string(), 22 22 content: l.optional(l.string()), 23 23 - encoding: l.optional(l.enum(['utf-8', 'base64'])), 23 23 + encoding: l.optional(l.enum(["utf-8", "base64"])), 24 24 size: l.optional(l.integer()), 25 25 isBinary: l.optional(l.boolean()), 26 26 mimeType: l.optional(l.string()), ··· 28 28 lastCommit: l.optional(l.ref<LastCommit>((() => lastCommit) as any)), 29 29 fileTooLarge: l.optional(l.boolean()), 30 30 }), 31 31 - ['RepoNotFound', 'RefNotFound', 'FileNotFound', 'InvalidRequest'], 32 32 - ) 33 33 - export { main } 31 31 + ["RepoNotFound", "RefNotFound", "FileNotFound", "InvalidRequest"], 32 32 + ); 33 33 + export { main }; 34 34 35 35 - export type $Params = l.InferMethodParams<typeof main> 36 36 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 37 37 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 38 38 - typeof main, 39 39 - B 40 40 - > 35 35 + export type $Params = l.InferMethodParams<typeof main>; 36 36 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 37 37 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 41 38 42 39 export const $lxm = main.nsid, 43 40 $params = main.parameters, 44 44 - $output = main.output 41 41 + $output = main.output; 45 42 46 43 type LastCommit = { 47 47 - $type?: 'sh.tangled.repo.blob#lastCommit' 44 44 + $type?: "sh.tangled.repo.blob#lastCommit"; 48 45 49 46 /** 50 47 * Commit hash 51 48 */ 52 52 - hash: string 49 49 + hash: string; 53 50 54 51 /** 55 52 * Commit message 56 53 */ 57 57 - message: string 58 58 - author?: Signature 54 54 + message: string; 55 55 + author?: Signature; 59 56 60 57 /** 61 58 * Commit timestamp 62 59 */ 63 63 - when: l.DatetimeString 64 64 - } 60 60 + when: l.DatetimeString; 61 61 + }; 65 62 66 66 - export type { LastCommit } 63 63 + export type { LastCommit }; 67 64 68 65 const lastCommit = l.typedObject<LastCommit>( 69 66 $nsid, 70 70 - 'lastCommit', 67 67 + "lastCommit", 71 68 l.object({ 72 69 hash: l.string(), 73 70 message: l.string(), 74 71 author: l.optional(l.ref<Signature>((() => signature) as any)), 75 75 - when: l.string({ format: 'datetime' }), 72 72 + when: l.string({ format: "datetime" }), 76 73 }), 77 77 - ) 74 74 + ); 78 75 79 79 - export { lastCommit } 76 76 + export { lastCommit }; 80 77 81 78 type Signature = { 82 82 - $type?: 'sh.tangled.repo.blob#signature' 79 79 + $type?: "sh.tangled.repo.blob#signature"; 83 80 84 81 /** 85 82 * Author name 86 83 */ 87 87 - name: string 84 84 + name: string; 88 85 89 86 /** 90 87 * Author email 91 88 */ 92 92 - email: string 89 89 + email: string; 93 90 94 91 /** 95 92 * Author timestamp 96 93 */ 97 97 - when: l.DatetimeString 98 98 - } 94 94 + when: l.DatetimeString; 95 95 + }; 99 96 100 100 - export type { Signature } 97 97 + export type { Signature }; 101 98 102 99 const signature = l.typedObject<Signature>( 103 100 $nsid, 104 104 - 'signature', 101 101 + "signature", 105 102 l.object({ 106 103 name: l.string(), 107 104 email: l.string(), 108 108 - when: l.string({ format: 'datetime' }), 105 105 + when: l.string({ format: "datetime" }), 109 106 }), 110 110 - ) 107 107 + ); 111 108 112 112 - export { signature } 109 109 + export { signature }; 113 110 114 111 type Submodule = { 115 115 - $type?: 'sh.tangled.repo.blob#submodule' 112 112 + $type?: "sh.tangled.repo.blob#submodule"; 116 113 117 114 /** 118 115 * Submodule name 119 116 */ 120 120 - name: string 117 117 + name: string; 121 118 122 119 /** 123 120 * Submodule repository URL 124 121 */ 125 125 - url: string 122 122 + url: string; 126 123 127 124 /** 128 125 * Branch to track in the submodule 129 126 */ 130 130 - branch?: string 131 131 - } 127 127 + branch?: string; 128 128 + }; 132 129 133 133 - export type { Submodule } 130 130 + export type { Submodule }; 134 131 135 132 const submodule = l.typedObject<Submodule>( 136 133 $nsid, 137 137 - 'submodule', 134 134 + "submodule", 138 135 l.object({ 139 136 name: l.string(), 140 137 url: l.string(), 141 138 branch: l.optional(l.string()), 142 139 }), 143 143 - ) 140 140 + ); 144 141 145 145 - export { submodule } 142 142 + export { submodule };

+2 -2

api/src/lexicons/sh/tangled/repo/blob.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './blob.defs.ts' 6 6 - export * as $defs from './blob.defs.ts' 5 5 + export * from "./blob.defs.ts"; 6 6 + export * as $defs from "./blob.defs.ts";

+21 -24

api/src/lexicons/sh/tangled/repo/branch.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.branch' 7 7 + const $nsid = "sh.tangled.repo.branch"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 const main = l.query( 12 12 $nsid, ··· 15 15 name: l.string(), 16 16 hash: l.string(), 17 17 shortHash: l.optional(l.string()), 18 18 - when: l.string({ format: 'datetime' }), 18 18 + when: l.string({ format: "datetime" }), 19 19 message: l.optional(l.string()), 20 20 author: l.optional(l.ref<Signature>((() => signature) as any)), 21 21 isDefault: l.optional(l.boolean()), 22 22 }), 23 23 - ['RepoNotFound', 'BranchNotFound', 'InvalidRequest'], 24 24 - ) 25 25 - export { main } 23 23 + ["RepoNotFound", "BranchNotFound", "InvalidRequest"], 24 24 + ); 25 25 + export { main }; 26 26 27 27 - export type $Params = l.InferMethodParams<typeof main> 28 28 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 29 29 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 30 30 - typeof main, 31 31 - B 32 32 - > 27 27 + export type $Params = l.InferMethodParams<typeof main>; 28 28 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 29 29 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 33 30 34 31 export const $lxm = main.nsid, 35 32 $params = main.parameters, 36 36 - $output = main.output 33 33 + $output = main.output; 37 34 38 35 type Signature = { 39 39 - $type?: 'sh.tangled.repo.branch#signature' 36 36 + $type?: "sh.tangled.repo.branch#signature"; 40 37 41 38 /** 42 39 * Author name 43 40 */ 44 44 - name: string 41 41 + name: string; 45 42 46 43 /** 47 44 * Author email 48 45 */ 49 49 - email: string 46 46 + email: string; 50 47 51 48 /** 52 49 * Author timestamp 53 50 */ 54 54 - when: l.DatetimeString 55 55 - } 51 51 + when: l.DatetimeString; 52 52 + }; 56 53 57 57 - export type { Signature } 54 54 + export type { Signature }; 58 55 59 56 const signature = l.typedObject<Signature>( 60 57 $nsid, 61 61 - 'signature', 58 58 + "signature", 62 59 l.object({ 63 60 name: l.string(), 64 61 email: l.string(), 65 65 - when: l.string({ format: 'datetime' }), 62 62 + when: l.string({ format: "datetime" }), 66 63 }), 67 67 - ) 64 64 + ); 68 65 69 69 - export { signature } 66 66 + export { signature };

+2 -2

api/src/lexicons/sh/tangled/repo/branch.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './branch.defs.ts' 6 6 - export * as $defs from './branch.defs.ts' 5 5 + export * from "./branch.defs.ts"; 6 6 + export * as $defs from "./branch.defs.ts";

+12 -17

api/src/lexicons/sh/tangled/repo/branches.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.branches' 7 7 + const $nsid = "sh.tangled.repo.branches"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 const main = l.query( 12 12 $nsid, 13 13 l.params({ 14 14 repo: l.string(), 15 15 - limit: l.optional( 16 16 - l.withDefault(l.integer({ minimum: 1, maximum: 100 }), 50), 17 17 - ), 15 15 + limit: l.optional(l.withDefault(l.integer({ minimum: 1, maximum: 100 }), 50)), 18 16 cursor: l.optional(l.string()), 19 17 }), 20 20 - l.payload('*/*'), 21 21 - ['RepoNotFound', 'InvalidRequest'], 22 22 - ) 23 23 - export { main } 18 18 + l.payload("*/*"), 19 19 + ["RepoNotFound", "InvalidRequest"], 20 20 + ); 21 21 + export { main }; 24 22 25 25 - export type $Params = l.InferMethodParams<typeof main> 26 26 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 27 27 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 28 28 - typeof main, 29 29 - B 30 30 - > 23 23 + export type $Params = l.InferMethodParams<typeof main>; 24 24 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 25 25 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 31 26 32 27 export const $lxm = main.nsid, 33 28 $params = main.parameters, 34 34 - $output = main.output 29 29 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/repo/branches.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './branches.defs.ts' 6 6 - export * as $defs from './branches.defs.ts' 5 5 + export * from "./branches.defs.ts"; 6 6 + export * as $defs from "./branches.defs.ts";

+20 -20

api/src/lexicons/sh/tangled/repo/collaborator.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.collaborator' 7 7 + const $nsid = "sh.tangled.repo.collaborator"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 type Main = { 12 12 - $type: 'sh.tangled.repo.collaborator' 13 13 - subject: l.DidString 12 12 + $type: "sh.tangled.repo.collaborator"; 13 13 + subject: l.DidString; 14 14 15 15 /** 16 16 * repo to add this user to 17 17 */ 18 18 - repo?: l.AtUriString 19 19 - repoDid?: l.DidString 20 20 - createdAt: l.DatetimeString 21 21 - } 18 18 + repo?: l.AtUriString; 19 19 + repoDid?: l.DidString; 20 20 + createdAt: l.DatetimeString; 21 21 + }; 22 22 23 23 - export type { Main } 23 23 + export type { Main }; 24 24 25 25 - const main = l.record<'tid', Main>( 26 26 - 'tid', 25 25 + const main = l.record<"tid", Main>( 26 26 + "tid", 27 27 $nsid, 28 28 l.object({ 29 29 - subject: l.string({ format: 'did' }), 30 30 - repo: l.optional(l.string({ format: 'at-uri' })), 31 31 - repoDid: l.optional(l.string({ format: 'did' })), 32 32 - createdAt: l.string({ format: 'datetime' }), 29 29 + subject: l.string({ format: "did" }), 30 30 + repo: l.optional(l.string({ format: "at-uri" })), 31 31 + repoDid: l.optional(l.string({ format: "did" })), 32 32 + createdAt: l.string({ format: "datetime" }), 33 33 }), 34 34 - ) 34 34 + ); 35 35 36 36 - export { main } 36 36 + export { main }; 37 37 38 38 export const $isTypeOf = /*#__PURE__*/ main.isTypeOf.bind(main), 39 39 $build = /*#__PURE__*/ main.build.bind(main), 40 40 - $type = /*#__PURE__*/ main.$type 40 40 + $type = /*#__PURE__*/ main.$type; 41 41 export const $assert = /*#__PURE__*/ main.assert.bind(main), 42 42 $check = /*#__PURE__*/ main.check.bind(main), 43 43 $cast = /*#__PURE__*/ main.cast.bind(main), ··· 46 46 $parse = /*#__PURE__*/ main.parse.bind(main), 47 47 $safeParse = /*#__PURE__*/ main.safeParse.bind(main), 48 48 $validate = /*#__PURE__*/ main.validate.bind(main), 49 49 - $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main) 49 49 + $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main);

+2 -2

api/src/lexicons/sh/tangled/repo/collaborator.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './collaborator.defs.ts' 6 6 - export * as $defs from './collaborator.defs.ts' 5 5 + export * from "./collaborator.defs.ts"; 6 6 + export * as $defs from "./collaborator.defs.ts";

+11 -14

api/src/lexicons/sh/tangled/repo/compare.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.compare' 7 7 + const $nsid = "sh.tangled.repo.compare"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 const main = l.query( 12 12 $nsid, 13 13 l.params({ repo: l.string(), rev1: l.string(), rev2: l.string() }), 14 14 - l.payload('*/*'), 15 15 - ['RepoNotFound', 'RevisionNotFound', 'InvalidRequest', 'CompareError'], 16 16 - ) 17 17 - export { main } 14 14 + l.payload("*/*"), 15 15 + ["RepoNotFound", "RevisionNotFound", "InvalidRequest", "CompareError"], 16 16 + ); 17 17 + export { main }; 18 18 19 19 - export type $Params = l.InferMethodParams<typeof main> 19 19 + export type $Params = l.InferMethodParams<typeof main>; 20 20 /** Compare output in application/json */ 21 21 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 21 21 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 22 22 /** Compare output in application/json */ 23 23 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 24 24 - typeof main, 25 25 - B 26 26 - > 23 23 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 27 24 28 25 export const $lxm = main.nsid, 29 26 $params = main.parameters, 30 30 - $output = main.output 27 27 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/repo/compare.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './compare.defs.ts' 6 6 - export * as $defs from './compare.defs.ts' 5 5 + export * from "./compare.defs.ts"; 6 6 + export * as $defs from "./compare.defs.ts";

+13 -19

api/src/lexicons/sh/tangled/repo/create.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.create' 7 7 + const $nsid = "sh.tangled.repo.create"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 /** Create a new repository */ 12 12 const main = l.procedure( ··· 17 17 name: l.string(), 18 18 defaultBranch: l.optional(l.string()), 19 19 source: l.optional(l.string()), 20 20 - repoDid: l.optional(l.string({ format: 'did' })), 20 20 + repoDid: l.optional(l.string({ format: "did" })), 21 21 }), 22 22 - l.jsonPayload({ repoDid: l.optional(l.string({ format: 'did' })) }), 23 23 - ) 24 24 - export { main } 22 22 + l.jsonPayload({ repoDid: l.optional(l.string({ format: "did" })) }), 23 23 + ); 24 24 + export { main }; 25 25 26 26 - export type $Params = l.InferMethodParams<typeof main> 27 27 - export type $Input<B = l.BinaryData> = l.InferMethodInput<typeof main, B> 28 28 - export type $InputBody<B = l.BinaryData> = l.InferMethodInputBody< 29 29 - typeof main, 30 30 - B 31 31 - > 32 32 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 33 33 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 34 34 - typeof main, 35 35 - B 36 36 - > 26 26 + export type $Params = l.InferMethodParams<typeof main>; 27 27 + export type $Input<B = l.BinaryData> = l.InferMethodInput<typeof main, B>; 28 28 + export type $InputBody<B = l.BinaryData> = l.InferMethodInputBody<typeof main, B>; 29 29 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 30 30 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 37 31 38 32 export const $lxm = main.nsid, 39 33 $params = main.parameters, 40 34 $input = main.input, 41 41 - $output = main.output 35 35 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/repo/create.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './create.defs.ts' 6 6 - export * as $defs from './create.defs.ts' 5 5 + export * from "./create.defs.ts"; 6 6 + export * as $defs from "./create.defs.ts";

+12 -18

api/src/lexicons/sh/tangled/repo/delete.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.delete' 7 7 + const $nsid = "sh.tangled.repo.delete"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 /** Delete a repository */ 12 12 const main = l.procedure( 13 13 $nsid, 14 14 l.params(), 15 15 l.jsonPayload({ 16 16 - did: l.string({ format: 'did' }), 16 16 + did: l.string({ format: "did" }), 17 17 name: l.string(), 18 18 rkey: l.string(), 19 19 }), 20 20 l.payload(), 21 21 - ) 22 22 - export { main } 21 21 + ); 22 22 + export { main }; 23 23 24 24 - export type $Params = l.InferMethodParams<typeof main> 25 25 - export type $Input<B = l.BinaryData> = l.InferMethodInput<typeof main, B> 26 26 - export type $InputBody<B = l.BinaryData> = l.InferMethodInputBody< 27 27 - typeof main, 28 28 - B 29 29 - > 30 30 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 31 31 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 32 32 - typeof main, 33 33 - B 34 34 - > 24 24 + export type $Params = l.InferMethodParams<typeof main>; 25 25 + export type $Input<B = l.BinaryData> = l.InferMethodInput<typeof main, B>; 26 26 + export type $InputBody<B = l.BinaryData> = l.InferMethodInputBody<typeof main, B>; 27 27 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 28 28 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 35 29 36 30 export const $lxm = main.nsid, 37 31 $params = main.parameters, 38 32 $input = main.input, 39 39 - $output = main.output 33 33 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/repo/delete.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './delete.defs.ts' 6 6 - export * as $defs from './delete.defs.ts' 5 5 + export * from "./delete.defs.ts"; 6 6 + export * as $defs from "./delete.defs.ts";

+12 -18

api/src/lexicons/sh/tangled/repo/deleteBranch.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.deleteBranch' 7 7 + const $nsid = "sh.tangled.repo.deleteBranch"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 /** Delete a branch on this repository */ 12 12 const main = l.procedure( 13 13 $nsid, 14 14 l.params(), 15 15 - l.jsonPayload({ repo: l.string({ format: 'at-uri' }), branch: l.string() }), 15 15 + l.jsonPayload({ repo: l.string({ format: "at-uri" }), branch: l.string() }), 16 16 l.payload(), 17 17 - ) 18 18 - export { main } 17 17 + ); 18 18 + export { main }; 19 19 20 20 - export type $Params = l.InferMethodParams<typeof main> 21 21 - export type $Input<B = l.BinaryData> = l.InferMethodInput<typeof main, B> 22 22 - export type $InputBody<B = l.BinaryData> = l.InferMethodInputBody< 23 23 - typeof main, 24 24 - B 25 25 - > 26 26 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 27 27 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 28 28 - typeof main, 29 29 - B 30 30 - > 20 20 + export type $Params = l.InferMethodParams<typeof main>; 21 21 + export type $Input<B = l.BinaryData> = l.InferMethodInput<typeof main, B>; 22 22 + export type $InputBody<B = l.BinaryData> = l.InferMethodInputBody<typeof main, B>; 23 23 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 24 24 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 31 25 32 26 export const $lxm = main.nsid, 33 27 $params = main.parameters, 34 28 $input = main.input, 35 35 - $output = main.output 29 29 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/repo/deleteBranch.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './deleteBranch.defs.ts' 6 6 - export * as $defs from './deleteBranch.defs.ts' 5 5 + export * from "./deleteBranch.defs.ts"; 6 6 + export * as $defs from "./deleteBranch.defs.ts";

+13 -17

api/src/lexicons/sh/tangled/repo/diff.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.diff' 7 7 + const $nsid = "sh.tangled.repo.diff"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 - const main = l.query( 12 12 - $nsid, 13 13 - l.params({ repo: l.string(), ref: l.string() }), 14 14 - l.payload('*/*'), 15 15 - ['RepoNotFound', 'RefNotFound', 'InvalidRequest'], 16 16 - ) 17 17 - export { main } 11 11 + const main = l.query($nsid, l.params({ repo: l.string(), ref: l.string() }), l.payload("*/*"), [ 12 12 + "RepoNotFound", 13 13 + "RefNotFound", 14 14 + "InvalidRequest", 15 15 + ]); 16 16 + export { main }; 18 17 19 19 - export type $Params = l.InferMethodParams<typeof main> 20 20 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 21 21 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 22 22 - typeof main, 23 23 - B 24 24 - > 18 18 + export type $Params = l.InferMethodParams<typeof main>; 19 19 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 20 20 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 25 21 26 22 export const $lxm = main.nsid, 27 23 $params = main.parameters, 28 28 - $output = main.output 24 24 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/repo/diff.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './diff.defs.ts' 6 6 - export * as $defs from './diff.defs.ts' 5 5 + export * from "./diff.defs.ts"; 6 6 + export * as $defs from "./diff.defs.ts";

+12 -18

api/src/lexicons/sh/tangled/repo/forkStatus.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.forkStatus' 7 7 + const $nsid = "sh.tangled.repo.forkStatus"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 /** Check fork status relative to upstream source */ 12 12 const main = l.procedure( 13 13 $nsid, 14 14 l.params(), 15 15 l.jsonPayload({ 16 16 - did: l.string({ format: 'did' }), 16 16 + did: l.string({ format: "did" }), 17 17 name: l.string(), 18 18 source: l.string(), 19 19 branch: l.string(), 20 20 hiddenRef: l.string(), 21 21 }), 22 22 l.jsonPayload({ status: l.integer() }), 23 23 - ) 24 24 - export { main } 23 23 + ); 24 24 + export { main }; 25 25 26 26 - export type $Params = l.InferMethodParams<typeof main> 27 27 - export type $Input<B = l.BinaryData> = l.InferMethodInput<typeof main, B> 28 28 - export type $InputBody<B = l.BinaryData> = l.InferMethodInputBody< 29 29 - typeof main, 30 30 - B 31 31 - > 32 32 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 33 33 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 34 34 - typeof main, 35 35 - B 36 36 - > 26 26 + export type $Params = l.InferMethodParams<typeof main>; 27 27 + export type $Input<B = l.BinaryData> = l.InferMethodInput<typeof main, B>; 28 28 + export type $InputBody<B = l.BinaryData> = l.InferMethodInputBody<typeof main, B>; 29 29 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 30 30 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 37 31 38 32 export const $lxm = main.nsid, 39 33 $params = main.parameters, 40 34 $input = main.input, 41 41 - $output = main.output 35 35 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/repo/forkStatus.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './forkStatus.defs.ts' 6 6 - export * as $defs from './forkStatus.defs.ts' 5 5 + export * from "./forkStatus.defs.ts"; 6 6 + export * as $defs from "./forkStatus.defs.ts";

+13 -19

api/src/lexicons/sh/tangled/repo/forkSync.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.forkSync' 7 7 + const $nsid = "sh.tangled.repo.forkSync"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 /** Sync a forked repository with its upstream source */ 12 12 const main = l.procedure( 13 13 $nsid, 14 14 l.params(), 15 15 l.jsonPayload({ 16 16 - did: l.string({ format: 'did' }), 17 17 - source: l.string({ format: 'at-uri' }), 16 16 + did: l.string({ format: "did" }), 17 17 + source: l.string({ format: "at-uri" }), 18 18 name: l.string(), 19 19 branch: l.string(), 20 20 }), 21 21 l.payload(), 22 22 - ) 23 23 - export { main } 22 22 + ); 23 23 + export { main }; 24 24 25 25 - export type $Params = l.InferMethodParams<typeof main> 26 26 - export type $Input<B = l.BinaryData> = l.InferMethodInput<typeof main, B> 27 27 - export type $InputBody<B = l.BinaryData> = l.InferMethodInputBody< 28 28 - typeof main, 29 29 - B 30 30 - > 31 31 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 32 32 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 33 33 - typeof main, 34 34 - B 35 35 - > 25 25 + export type $Params = l.InferMethodParams<typeof main>; 26 26 + export type $Input<B = l.BinaryData> = l.InferMethodInput<typeof main, B>; 27 27 + export type $InputBody<B = l.BinaryData> = l.InferMethodInputBody<typeof main, B>; 28 28 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 29 29 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 36 30 37 31 export const $lxm = main.nsid, 38 32 $params = main.parameters, 39 33 $input = main.input, 40 40 - $output = main.output 34 34 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/repo/forkSync.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './forkSync.defs.ts' 6 6 - export * as $defs from './forkSync.defs.ts' 5 5 + export * from "./forkSync.defs.ts"; 6 6 + export * as $defs from "./forkSync.defs.ts";

+21 -24

api/src/lexicons/sh/tangled/repo/getDefaultBranch.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.getDefaultBranch' 7 7 + const $nsid = "sh.tangled.repo.getDefaultBranch"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 const main = l.query( 12 12 $nsid, ··· 15 15 name: l.string(), 16 16 hash: l.string(), 17 17 shortHash: l.optional(l.string()), 18 18 - when: l.string({ format: 'datetime' }), 18 18 + when: l.string({ format: "datetime" }), 19 19 message: l.optional(l.string()), 20 20 author: l.optional(l.ref<Signature>((() => signature) as any)), 21 21 }), 22 22 - ['RepoNotFound', 'InvalidRequest'], 23 23 - ) 24 24 - export { main } 22 22 + ["RepoNotFound", "InvalidRequest"], 23 23 + ); 24 24 + export { main }; 25 25 26 26 - export type $Params = l.InferMethodParams<typeof main> 27 27 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 28 28 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 29 29 - typeof main, 30 30 - B 31 31 - > 26 26 + export type $Params = l.InferMethodParams<typeof main>; 27 27 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 28 28 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 32 29 33 30 export const $lxm = main.nsid, 34 31 $params = main.parameters, 35 35 - $output = main.output 32 32 + $output = main.output; 36 33 37 34 type Signature = { 38 38 - $type?: 'sh.tangled.repo.getDefaultBranch#signature' 35 35 + $type?: "sh.tangled.repo.getDefaultBranch#signature"; 39 36 40 37 /** 41 38 * Author name 42 39 */ 43 43 - name: string 40 40 + name: string; 44 41 45 42 /** 46 43 * Author email 47 44 */ 48 48 - email: string 45 45 + email: string; 49 46 50 47 /** 51 48 * Author timestamp 52 49 */ 53 53 - when: l.DatetimeString 54 54 - } 50 50 + when: l.DatetimeString; 51 51 + }; 55 52 56 56 - export type { Signature } 53 53 + export type { Signature }; 57 54 58 55 const signature = l.typedObject<Signature>( 59 56 $nsid, 60 60 - 'signature', 57 57 + "signature", 61 58 l.object({ 62 59 name: l.string(), 63 60 email: l.string(), 64 64 - when: l.string({ format: 'datetime' }), 61 61 + when: l.string({ format: "datetime" }), 65 62 }), 66 66 - ) 63 63 + ); 67 64 68 68 - export { signature } 65 65 + export { signature };

+2 -2

api/src/lexicons/sh/tangled/repo/getDefaultBranch.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './getDefaultBranch.defs.ts' 6 6 - export * as $defs from './getDefaultBranch.defs.ts' 5 5 + export * from "./getDefaultBranch.defs.ts"; 6 6 + export * as $defs from "./getDefaultBranch.defs.ts";

+12 -18

api/src/lexicons/sh/tangled/repo/hiddenRef.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.hiddenRef' 7 7 + const $nsid = "sh.tangled.repo.hiddenRef"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 /** Create a hidden ref in a repository */ 12 12 const main = l.procedure( 13 13 $nsid, 14 14 l.params(), 15 15 l.jsonPayload({ 16 16 - repo: l.string({ format: 'at-uri' }), 16 16 + repo: l.string({ format: "at-uri" }), 17 17 forkRef: l.string(), 18 18 remoteRef: l.string(), 19 19 }), ··· 22 22 ref: l.optional(l.string()), 23 23 error: l.optional(l.string()), 24 24 }), 25 25 - ) 26 26 - export { main } 25 25 + ); 26 26 + export { main }; 27 27 28 28 - export type $Params = l.InferMethodParams<typeof main> 29 29 - export type $Input<B = l.BinaryData> = l.InferMethodInput<typeof main, B> 30 30 - export type $InputBody<B = l.BinaryData> = l.InferMethodInputBody< 31 31 - typeof main, 32 32 - B 33 33 - > 34 34 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 35 35 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 36 36 - typeof main, 37 37 - B 38 38 - > 28 28 + export type $Params = l.InferMethodParams<typeof main>; 29 29 + export type $Input<B = l.BinaryData> = l.InferMethodInput<typeof main, B>; 30 30 + export type $InputBody<B = l.BinaryData> = l.InferMethodInputBody<typeof main, B>; 31 31 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 32 32 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 39 33 40 34 export const $lxm = main.nsid, 41 35 $params = main.parameters, 42 36 $input = main.input, 43 43 - $output = main.output 37 37 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/repo/hiddenRef.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './hiddenRef.defs.ts' 6 6 - export * as $defs from './hiddenRef.defs.ts' 5 5 + export * from "./hiddenRef.defs.ts"; 6 6 + export * as $defs from "./hiddenRef.defs.ts";

+24 -24

api/src/lexicons/sh/tangled/repo/issue.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.issue' 7 7 + const $nsid = "sh.tangled.repo.issue"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 type Main = { 12 12 - $type: 'sh.tangled.repo.issue' 13 13 - repo?: l.AtUriString 14 14 - repoDid?: l.DidString 15 15 - title: string 16 16 - body?: string 17 17 - createdAt: l.DatetimeString 18 18 - mentions?: l.DidString[] 19 19 - references?: l.AtUriString[] 20 20 - } 12 12 + $type: "sh.tangled.repo.issue"; 13 13 + repo?: l.AtUriString; 14 14 + repoDid?: l.DidString; 15 15 + title: string; 16 16 + body?: string; 17 17 + createdAt: l.DatetimeString; 18 18 + mentions?: l.DidString[]; 19 19 + references?: l.AtUriString[]; 20 20 + }; 21 21 22 22 - export type { Main } 22 22 + export type { Main }; 23 23 24 24 - const main = l.record<'tid', Main>( 25 25 - 'tid', 24 24 + const main = l.record<"tid", Main>( 25 25 + "tid", 26 26 $nsid, 27 27 l.object({ 28 28 - repo: l.optional(l.string({ format: 'at-uri' })), 29 29 - repoDid: l.optional(l.string({ format: 'did' })), 28 28 + repo: l.optional(l.string({ format: "at-uri" })), 29 29 + repoDid: l.optional(l.string({ format: "did" })), 30 30 title: l.string(), 31 31 body: l.optional(l.string()), 32 32 - createdAt: l.string({ format: 'datetime' }), 33 33 - mentions: l.optional(l.array(l.string({ format: 'did' }))), 34 34 - references: l.optional(l.array(l.string({ format: 'at-uri' }))), 32 32 + createdAt: l.string({ format: "datetime" }), 33 33 + mentions: l.optional(l.array(l.string({ format: "did" }))), 34 34 + references: l.optional(l.array(l.string({ format: "at-uri" }))), 35 35 }), 36 36 - ) 36 36 + ); 37 37 38 38 - export { main } 38 38 + export { main }; 39 39 40 40 export const $isTypeOf = /*#__PURE__*/ main.isTypeOf.bind(main), 41 41 $build = /*#__PURE__*/ main.build.bind(main), 42 42 - $type = /*#__PURE__*/ main.$type 42 42 + $type = /*#__PURE__*/ main.$type; 43 43 export const $assert = /*#__PURE__*/ main.assert.bind(main), 44 44 $check = /*#__PURE__*/ main.check.bind(main), 45 45 $cast = /*#__PURE__*/ main.cast.bind(main), ··· 48 48 $parse = /*#__PURE__*/ main.parse.bind(main), 49 49 $safeParse = /*#__PURE__*/ main.safeParse.bind(main), 50 50 $validate = /*#__PURE__*/ main.validate.bind(main), 51 51 - $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main) 51 51 + $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main);

+4 -4

api/src/lexicons/sh/tangled/repo/issue.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * as state from './issue/state.ts' 6 6 - export * as comment from './issue/comment.ts' 7 7 - export * from './issue.defs.ts' 8 8 - export * as $defs from './issue.defs.ts' 5 5 + export * as state from "./issue/state.ts"; 6 6 + export * as comment from "./issue/comment.ts"; 7 7 + export * from "./issue.defs.ts"; 8 8 + export * as $defs from "./issue.defs.ts";

+23 -23

api/src/lexicons/sh/tangled/repo/issue/comment.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.issue.comment' 7 7 + const $nsid = "sh.tangled.repo.issue.comment"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 type Main = { 12 12 - $type: 'sh.tangled.repo.issue.comment' 13 13 - issue: l.AtUriString 14 14 - body: string 15 15 - createdAt: l.DatetimeString 16 16 - replyTo?: l.AtUriString 17 17 - mentions?: l.DidString[] 18 18 - references?: l.AtUriString[] 19 19 - } 12 12 + $type: "sh.tangled.repo.issue.comment"; 13 13 + issue: l.AtUriString; 14 14 + body: string; 15 15 + createdAt: l.DatetimeString; 16 16 + replyTo?: l.AtUriString; 17 17 + mentions?: l.DidString[]; 18 18 + references?: l.AtUriString[]; 19 19 + }; 20 20 21 21 - export type { Main } 21 21 + export type { Main }; 22 22 23 23 - const main = l.record<'tid', Main>( 24 24 - 'tid', 23 23 + const main = l.record<"tid", Main>( 24 24 + "tid", 25 25 $nsid, 26 26 l.object({ 27 27 - issue: l.string({ format: 'at-uri' }), 27 27 + issue: l.string({ format: "at-uri" }), 28 28 body: l.string(), 29 29 - createdAt: l.string({ format: 'datetime' }), 30 30 - replyTo: l.optional(l.string({ format: 'at-uri' })), 31 31 - mentions: l.optional(l.array(l.string({ format: 'did' }))), 32 32 - references: l.optional(l.array(l.string({ format: 'at-uri' }))), 29 29 + createdAt: l.string({ format: "datetime" }), 30 30 + replyTo: l.optional(l.string({ format: "at-uri" })), 31 31 + mentions: l.optional(l.array(l.string({ format: "did" }))), 32 32 + references: l.optional(l.array(l.string({ format: "at-uri" }))), 33 33 }), 34 34 - ) 34 34 + ); 35 35 36 36 - export { main } 36 36 + export { main }; 37 37 38 38 export const $isTypeOf = /*#__PURE__*/ main.isTypeOf.bind(main), 39 39 $build = /*#__PURE__*/ main.build.bind(main), 40 40 - $type = /*#__PURE__*/ main.$type 40 40 + $type = /*#__PURE__*/ main.$type; 41 41 export const $assert = /*#__PURE__*/ main.assert.bind(main), 42 42 $check = /*#__PURE__*/ main.check.bind(main), 43 43 $cast = /*#__PURE__*/ main.cast.bind(main), ··· 46 46 $parse = /*#__PURE__*/ main.parse.bind(main), 47 47 $safeParse = /*#__PURE__*/ main.safeParse.bind(main), 48 48 $validate = /*#__PURE__*/ main.validate.bind(main), 49 49 - $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main) 49 49 + $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main);

+2 -2

api/src/lexicons/sh/tangled/repo/issue/comment.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './comment.defs.ts' 6 6 - export * as $defs from './comment.defs.ts' 5 5 + export * from "./comment.defs.ts"; 6 6 + export * as $defs from "./comment.defs.ts";

+19 -22

api/src/lexicons/sh/tangled/repo/issue/state.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.issue.state' 7 7 + const $nsid = "sh.tangled.repo.issue.state"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 type Main = { 12 12 - $type: 'sh.tangled.repo.issue.state' 13 13 - issue: l.AtUriString 12 12 + $type: "sh.tangled.repo.issue.state"; 13 13 + issue: l.AtUriString; 14 14 15 15 /** 16 16 * state of the issue 17 17 */ 18 18 state: 19 19 - | 'sh.tangled.repo.issue.state.open' 20 20 - | 'sh.tangled.repo.issue.state.closed' 21 21 - | l.UnknownString 22 22 - } 19 19 + | "sh.tangled.repo.issue.state.open" 20 20 + | "sh.tangled.repo.issue.state.closed" 21 21 + | l.UnknownString; 22 22 + }; 23 23 24 24 - export type { Main } 24 24 + export type { Main }; 25 25 26 26 - const main = l.record<'tid', Main>( 27 27 - 'tid', 26 26 + const main = l.record<"tid", Main>( 27 27 + "tid", 28 28 $nsid, 29 29 l.object({ 30 30 - issue: l.string({ format: 'at-uri' }), 30 30 + issue: l.string({ format: "at-uri" }), 31 31 state: l.withDefault( 32 32 l.string<{ 33 33 - knownValues: [ 34 34 - 'sh.tangled.repo.issue.state.open', 35 35 - 'sh.tangled.repo.issue.state.closed', 36 36 - ] 33 33 + knownValues: ["sh.tangled.repo.issue.state.open", "sh.tangled.repo.issue.state.closed"]; 37 34 }>(), 38 38 - 'sh.tangled.repo.issue.state.open', 35 35 + "sh.tangled.repo.issue.state.open", 39 36 ), 40 37 }), 41 41 - ) 38 38 + ); 42 39 43 43 - export { main } 40 40 + export { main }; 44 41 45 42 export const $isTypeOf = /*#__PURE__*/ main.isTypeOf.bind(main), 46 43 $build = /*#__PURE__*/ main.build.bind(main), 47 47 - $type = /*#__PURE__*/ main.$type 44 44 + $type = /*#__PURE__*/ main.$type; 48 45 export const $assert = /*#__PURE__*/ main.assert.bind(main), 49 46 $check = /*#__PURE__*/ main.check.bind(main), 50 47 $cast = /*#__PURE__*/ main.cast.bind(main), ··· 53 50 $parse = /*#__PURE__*/ main.parse.bind(main), 54 51 $safeParse = /*#__PURE__*/ main.safeParse.bind(main), 55 52 $validate = /*#__PURE__*/ main.validate.bind(main), 56 56 - $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main) 53 53 + $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main);

+4 -4

api/src/lexicons/sh/tangled/repo/issue/state.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * as closed from './state/closed.ts' 6 6 - export * as open from './state/open.ts' 7 7 - export * from './state.defs.ts' 8 8 - export * as $defs from './state.defs.ts' 5 5 + export * as closed from "./state/closed.ts"; 6 6 + export * as open from "./state/open.ts"; 7 7 + export * from "./state.defs.ts"; 8 8 + export * as $defs from "./state.defs.ts";

+8 -8

api/src/lexicons/sh/tangled/repo/issue/state/closed.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.issue.state.closed' 7 7 + const $nsid = "sh.tangled.repo.issue.state.closed"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 /** closed issue */ 12 12 - type Main = 'sh.tangled.repo.issue.state.closed' 12 12 + type Main = "sh.tangled.repo.issue.state.closed"; 13 13 14 14 - export type { Main } 14 14 + export type { Main }; 15 15 16 16 /** closed issue */ 17 17 - const main = l.token($nsid, 'main') 17 17 + const main = l.token($nsid, "main"); 18 18 19 19 - export { main } 19 19 + export { main }; 20 20 21 21 export const $assert = /*#__PURE__*/ main.assert.bind(main), 22 22 $check = /*#__PURE__*/ main.check.bind(main), ··· 26 26 $parse = /*#__PURE__*/ main.parse.bind(main), 27 27 $safeParse = /*#__PURE__*/ main.safeParse.bind(main), 28 28 $validate = /*#__PURE__*/ main.validate.bind(main), 29 29 - $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main) 29 29 + $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main);

+2 -2

api/src/lexicons/sh/tangled/repo/issue/state/closed.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './closed.defs.ts' 6 6 - export * as $defs from './closed.defs.ts' 5 5 + export * from "./closed.defs.ts"; 6 6 + export * as $defs from "./closed.defs.ts";

+8 -8

api/src/lexicons/sh/tangled/repo/issue/state/open.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.issue.state.open' 7 7 + const $nsid = "sh.tangled.repo.issue.state.open"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 /** open issue */ 12 12 - type Main = 'sh.tangled.repo.issue.state.open' 12 12 + type Main = "sh.tangled.repo.issue.state.open"; 13 13 14 14 - export type { Main } 14 14 + export type { Main }; 15 15 16 16 /** open issue */ 17 17 - const main = l.token($nsid, 'main') 17 17 + const main = l.token($nsid, "main"); 18 18 19 19 - export { main } 19 19 + export { main }; 20 20 21 21 export const $assert = /*#__PURE__*/ main.assert.bind(main), 22 22 $check = /*#__PURE__*/ main.check.bind(main), ··· 26 26 $parse = /*#__PURE__*/ main.parse.bind(main), 27 27 $safeParse = /*#__PURE__*/ main.safeParse.bind(main), 28 28 $validate = /*#__PURE__*/ main.validate.bind(main), 29 29 - $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main) 29 29 + $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main);

+2 -2

api/src/lexicons/sh/tangled/repo/issue/state/open.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './open.defs.ts' 6 6 - export * as $defs from './open.defs.ts' 5 5 + export * from "./open.defs.ts"; 6 6 + export * as $defs from "./open.defs.ts";

+23 -26

api/src/lexicons/sh/tangled/repo/languages.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.languages' 7 7 + const $nsid = "sh.tangled.repo.languages"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 const main = l.query( 12 12 $nsid, 13 13 l.params({ 14 14 repo: l.string(), 15 15 - ref: l.optional(l.withDefault(l.string(), 'HEAD')), 15 15 + ref: l.optional(l.withDefault(l.string(), "HEAD")), 16 16 }), 17 17 l.jsonPayload({ 18 18 ref: l.string(), ··· 20 20 totalSize: l.optional(l.integer()), 21 21 totalFiles: l.optional(l.integer()), 22 22 }), 23 23 - ['RepoNotFound', 'RefNotFound', 'InvalidRequest'], 24 24 - ) 25 25 - export { main } 23 23 + ["RepoNotFound", "RefNotFound", "InvalidRequest"], 24 24 + ); 25 25 + export { main }; 26 26 27 27 - export type $Params = l.InferMethodParams<typeof main> 28 28 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 29 29 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 30 30 - typeof main, 31 31 - B 32 32 - > 27 27 + export type $Params = l.InferMethodParams<typeof main>; 28 28 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 29 29 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 33 30 34 31 export const $lxm = main.nsid, 35 32 $params = main.parameters, 36 36 - $output = main.output 33 33 + $output = main.output; 37 34 38 35 type Language = { 39 39 - $type?: 'sh.tangled.repo.languages#language' 36 36 + $type?: "sh.tangled.repo.languages#language"; 40 37 41 38 /** 42 39 * Programming language name 43 40 */ 44 44 - name: string 41 41 + name: string; 45 42 46 43 /** 47 44 * Total size of files in this language (bytes) 48 45 */ 49 49 - size: number 46 46 + size: number; 50 47 51 48 /** 52 49 * Percentage of total codebase (0-100) 53 50 */ 54 54 - percentage: number 51 51 + percentage: number; 55 52 56 53 /** 57 54 * Number of files in this language 58 55 */ 59 59 - fileCount?: number 56 56 + fileCount?: number; 60 57 61 58 /** 62 59 * Hex color code for this language 63 60 */ 64 64 - color?: string 61 61 + color?: string; 65 62 66 63 /** 67 64 * File extensions associated with this language 68 65 */ 69 69 - extensions?: string[] 70 70 - } 66 66 + extensions?: string[]; 67 67 + }; 71 68 72 72 - export type { Language } 69 69 + export type { Language }; 73 70 74 71 const language = l.typedObject<Language>( 75 72 $nsid, 76 76 - 'language', 73 73 + "language", 77 74 l.object({ 78 75 name: l.string(), 79 76 size: l.integer(), ··· 82 79 color: l.optional(l.string()), 83 80 extensions: l.optional(l.array(l.string())), 84 81 }), 85 85 - ) 82 82 + ); 86 83 87 87 - export { language } 84 84 + export { language };

+2 -2

api/src/lexicons/sh/tangled/repo/languages.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './languages.defs.ts' 6 6 - export * as $defs from './languages.defs.ts' 5 5 + export * from "./languages.defs.ts"; 6 6 + export * as $defs from "./languages.defs.ts";

+23 -26

api/src/lexicons/sh/tangled/repo/listSecrets.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.listSecrets' 7 7 + const $nsid = "sh.tangled.repo.listSecrets"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 const main = l.query( 12 12 $nsid, 13 13 - l.params({ repo: l.string({ format: 'at-uri' }) }), 13 13 + l.params({ repo: l.string({ format: "at-uri" }) }), 14 14 l.jsonPayload({ secrets: l.array(l.ref<Secret>((() => secret) as any)) }), 15 15 - ) 16 16 - export { main } 15 15 + ); 16 16 + export { main }; 17 17 18 18 - export type $Params = l.InferMethodParams<typeof main> 19 19 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 20 20 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 21 21 - typeof main, 22 22 - B 23 23 - > 18 18 + export type $Params = l.InferMethodParams<typeof main>; 19 19 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 20 20 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 24 21 25 22 export const $lxm = main.nsid, 26 23 $params = main.parameters, 27 27 - $output = main.output 24 24 + $output = main.output; 28 25 29 26 type Secret = { 30 30 - $type?: 'sh.tangled.repo.listSecrets#secret' 31 31 - repo: l.AtUriString 32 32 - key: string 33 33 - createdAt: l.DatetimeString 34 34 - createdBy: l.DidString 35 35 - } 27 27 + $type?: "sh.tangled.repo.listSecrets#secret"; 28 28 + repo: l.AtUriString; 29 29 + key: string; 30 30 + createdAt: l.DatetimeString; 31 31 + createdBy: l.DidString; 32 32 + }; 36 33 37 37 - export type { Secret } 34 34 + export type { Secret }; 38 35 39 36 const secret = l.typedObject<Secret>( 40 37 $nsid, 41 41 - 'secret', 38 38 + "secret", 42 39 l.object({ 43 43 - repo: l.string({ format: 'at-uri' }), 40 40 + repo: l.string({ format: "at-uri" }), 44 41 key: l.string({ maxLength: 50, minLength: 1 }), 45 45 - createdAt: l.string({ format: 'datetime' }), 46 46 - createdBy: l.string({ format: 'did' }), 42 42 + createdAt: l.string({ format: "datetime" }), 43 43 + createdBy: l.string({ format: "did" }), 47 44 }), 48 48 - ) 45 45 + ); 49 46 50 50 - export { secret } 47 47 + export { secret };

+2 -2

api/src/lexicons/sh/tangled/repo/listSecrets.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './listSecrets.defs.ts' 6 6 - export * as $defs from './listSecrets.defs.ts' 5 5 + export * from "./listSecrets.defs.ts"; 6 6 + export * as $defs from "./listSecrets.defs.ts";

+13 -18

api/src/lexicons/sh/tangled/repo/log.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.log' 7 7 + const $nsid = "sh.tangled.repo.log"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 const main = l.query( 12 12 $nsid, 13 13 l.params({ 14 14 repo: l.string(), 15 15 ref: l.string(), 16 16 - path: l.optional(l.withDefault(l.string(), '')), 17 17 - limit: l.optional( 18 18 - l.withDefault(l.integer({ minimum: 1, maximum: 100 }), 50), 19 19 - ), 16 16 + path: l.optional(l.withDefault(l.string(), "")), 17 17 + limit: l.optional(l.withDefault(l.integer({ minimum: 1, maximum: 100 }), 50)), 20 18 cursor: l.optional(l.string()), 21 19 }), 22 22 - l.payload('*/*'), 23 23 - ['RepoNotFound', 'RefNotFound', 'PathNotFound', 'InvalidRequest'], 24 24 - ) 25 25 - export { main } 20 20 + l.payload("*/*"), 21 21 + ["RepoNotFound", "RefNotFound", "PathNotFound", "InvalidRequest"], 22 22 + ); 23 23 + export { main }; 26 24 27 27 - export type $Params = l.InferMethodParams<typeof main> 28 28 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 29 29 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 30 30 - typeof main, 31 31 - B 32 32 - > 25 25 + export type $Params = l.InferMethodParams<typeof main>; 26 26 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 27 27 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 33 28 34 29 export const $lxm = main.nsid, 35 30 $params = main.parameters, 36 36 - $output = main.output 31 31 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/repo/log.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './log.defs.ts' 6 6 - export * as $defs from './log.defs.ts' 5 5 + export * from "./log.defs.ts"; 6 6 + export * as $defs from "./log.defs.ts";

+12 -18

api/src/lexicons/sh/tangled/repo/merge.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.merge' 7 7 + const $nsid = "sh.tangled.repo.merge"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 /** Merge a patch into a repository branch */ 12 12 const main = l.procedure( 13 13 $nsid, 14 14 l.params(), 15 15 l.jsonPayload({ 16 16 - did: l.string({ format: 'did' }), 16 16 + did: l.string({ format: "did" }), 17 17 name: l.string(), 18 18 patch: l.string(), 19 19 branch: l.string(), ··· 23 23 commitMessage: l.optional(l.string()), 24 24 }), 25 25 l.payload(), 26 26 - ) 27 27 - export { main } 26 26 + ); 27 27 + export { main }; 28 28 29 29 - export type $Params = l.InferMethodParams<typeof main> 30 30 - export type $Input<B = l.BinaryData> = l.InferMethodInput<typeof main, B> 31 31 - export type $InputBody<B = l.BinaryData> = l.InferMethodInputBody< 32 32 - typeof main, 33 33 - B 34 34 - > 35 35 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 36 36 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 37 37 - typeof main, 38 38 - B 39 39 - > 29 29 + export type $Params = l.InferMethodParams<typeof main>; 30 30 + export type $Input<B = l.BinaryData> = l.InferMethodInput<typeof main, B>; 31 31 + export type $InputBody<B = l.BinaryData> = l.InferMethodInputBody<typeof main, B>; 32 32 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 33 33 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 40 34 41 35 export const $lxm = main.nsid, 42 36 $params = main.parameters, 43 37 $input = main.input, 44 44 - $output = main.output 38 38 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/repo/merge.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './merge.defs.ts' 6 6 - export * as $defs from './merge.defs.ts' 5 5 + export * from "./merge.defs.ts"; 6 6 + export * as $defs from "./merge.defs.ts";

+21 -29

api/src/lexicons/sh/tangled/repo/mergeCheck.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.mergeCheck' 7 7 + const $nsid = "sh.tangled.repo.mergeCheck"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 /** Check if a merge is possible between two branches */ 12 12 const main = l.procedure( 13 13 $nsid, 14 14 l.params(), 15 15 l.jsonPayload({ 16 16 - did: l.string({ format: 'did' }), 16 16 + did: l.string({ format: "did" }), 17 17 name: l.string(), 18 18 patch: l.string(), 19 19 branch: l.string(), 20 20 }), 21 21 l.jsonPayload({ 22 22 is_conflicted: l.boolean(), 23 23 - conflicts: l.optional( 24 24 - l.array(l.ref<ConflictInfo>((() => conflictInfo) as any)), 25 25 - ), 23 23 + conflicts: l.optional(l.array(l.ref<ConflictInfo>((() => conflictInfo) as any))), 26 24 message: l.optional(l.string()), 27 25 error: l.optional(l.string()), 28 26 }), 29 29 - ) 30 30 - export { main } 27 27 + ); 28 28 + export { main }; 31 29 32 32 - export type $Params = l.InferMethodParams<typeof main> 33 33 - export type $Input<B = l.BinaryData> = l.InferMethodInput<typeof main, B> 34 34 - export type $InputBody<B = l.BinaryData> = l.InferMethodInputBody< 35 35 - typeof main, 36 36 - B 37 37 - > 38 38 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 39 39 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 40 40 - typeof main, 41 41 - B 42 42 - > 30 30 + export type $Params = l.InferMethodParams<typeof main>; 31 31 + export type $Input<B = l.BinaryData> = l.InferMethodInput<typeof main, B>; 32 32 + export type $InputBody<B = l.BinaryData> = l.InferMethodInputBody<typeof main, B>; 33 33 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 34 34 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 43 35 44 36 export const $lxm = main.nsid, 45 37 $params = main.parameters, 46 38 $input = main.input, 47 47 - $output = main.output 39 39 + $output = main.output; 48 40 49 41 type ConflictInfo = { 50 50 - $type?: 'sh.tangled.repo.mergeCheck#conflictInfo' 42 42 + $type?: "sh.tangled.repo.mergeCheck#conflictInfo"; 51 43 52 44 /** 53 45 * Name of the conflicted file 54 46 */ 55 55 - filename: string 47 47 + filename: string; 56 48 57 49 /** 58 50 * Reason for the conflict 59 51 */ 60 60 - reason: string 61 61 - } 52 52 + reason: string; 53 53 + }; 62 54 63 63 - export type { ConflictInfo } 55 55 + export type { ConflictInfo }; 64 56 65 57 const conflictInfo = l.typedObject<ConflictInfo>( 66 58 $nsid, 67 67 - 'conflictInfo', 59 59 + "conflictInfo", 68 60 l.object({ filename: l.string(), reason: l.string() }), 69 69 - ) 61 61 + ); 70 62 71 71 - export { conflictInfo } 63 63 + export { conflictInfo };

+2 -2

api/src/lexicons/sh/tangled/repo/mergeCheck.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './mergeCheck.defs.ts' 6 6 - export * as $defs from './mergeCheck.defs.ts' 5 5 + export * from "./mergeCheck.defs.ts"; 6 6 + export * as $defs from "./mergeCheck.defs.ts";

+57 -57

api/src/lexicons/sh/tangled/repo/pull.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.pull' 7 7 + const $nsid = "sh.tangled.repo.pull"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 type Main = { 12 12 - $type: 'sh.tangled.repo.pull' 13 13 - title: string 14 14 - body?: string 15 15 - rounds: Round[] 16 16 - source?: Source 17 17 - target: Target 18 18 - createdAt: l.DatetimeString 19 19 - mentions?: l.DidString[] 20 20 - references?: l.AtUriString[] 21 21 - dependentOn?: l.AtUriString 22 22 - } 12 12 + $type: "sh.tangled.repo.pull"; 13 13 + title: string; 14 14 + body?: string; 15 15 + rounds: Round[]; 16 16 + source?: Source; 17 17 + target: Target; 18 18 + createdAt: l.DatetimeString; 19 19 + mentions?: l.DidString[]; 20 20 + references?: l.AtUriString[]; 21 21 + dependentOn?: l.AtUriString; 22 22 + }; 23 23 24 24 - export type { Main } 24 24 + export type { Main }; 25 25 26 26 - const main = l.record<'tid', Main>( 27 27 - 'tid', 26 26 + const main = l.record<"tid", Main>( 27 27 + "tid", 28 28 $nsid, 29 29 l.object({ 30 30 title: l.string(), ··· 32 32 rounds: l.array(l.ref<Round>((() => round) as any)), 33 33 source: l.optional(l.ref<Source>((() => source) as any)), 34 34 target: l.ref<Target>((() => target) as any), 35 35 - createdAt: l.string({ format: 'datetime' }), 36 36 - mentions: l.optional(l.array(l.string({ format: 'did' }))), 37 37 - references: l.optional(l.array(l.string({ format: 'at-uri' }))), 38 38 - dependentOn: l.optional(l.string({ format: 'at-uri' })), 35 35 + createdAt: l.string({ format: "datetime" }), 36 36 + mentions: l.optional(l.array(l.string({ format: "did" }))), 37 37 + references: l.optional(l.array(l.string({ format: "at-uri" }))), 38 38 + dependentOn: l.optional(l.string({ format: "at-uri" })), 39 39 }), 40 40 - ) 40 40 + ); 41 41 42 42 - export { main } 42 42 + export { main }; 43 43 44 44 export const $isTypeOf = /*#__PURE__*/ main.isTypeOf.bind(main), 45 45 $build = /*#__PURE__*/ main.build.bind(main), 46 46 - $type = /*#__PURE__*/ main.$type 46 46 + $type = /*#__PURE__*/ main.$type; 47 47 export const $assert = /*#__PURE__*/ main.assert.bind(main), 48 48 $check = /*#__PURE__*/ main.check.bind(main), 49 49 $cast = /*#__PURE__*/ main.cast.bind(main), ··· 52 52 $parse = /*#__PURE__*/ main.parse.bind(main), 53 53 $safeParse = /*#__PURE__*/ main.safeParse.bind(main), 54 54 $validate = /*#__PURE__*/ main.validate.bind(main), 55 55 - $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main) 55 55 + $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main); 56 56 57 57 type Target = { 58 58 - $type?: 'sh.tangled.repo.pull#target' 59 59 - repo?: l.AtUriString 60 60 - repoDid?: l.DidString 61 61 - branch: string 62 62 - } 58 58 + $type?: "sh.tangled.repo.pull#target"; 59 59 + repo?: l.AtUriString; 60 60 + repoDid?: l.DidString; 61 61 + branch: string; 62 62 + }; 63 63 64 64 - export type { Target } 64 64 + export type { Target }; 65 65 66 66 const target = l.typedObject<Target>( 67 67 $nsid, 68 68 - 'target', 68 68 + "target", 69 69 l.object({ 70 70 - repo: l.optional(l.string({ format: 'at-uri' })), 71 71 - repoDid: l.optional(l.string({ format: 'did' })), 70 70 + repo: l.optional(l.string({ format: "at-uri" })), 71 71 + repoDid: l.optional(l.string({ format: "did" })), 72 72 branch: l.string(), 73 73 }), 74 74 - ) 74 74 + ); 75 75 76 76 - export { target } 76 76 + export { target }; 77 77 78 78 type Source = { 79 79 - $type?: 'sh.tangled.repo.pull#source' 80 80 - branch: string 81 81 - repo?: l.AtUriString 82 82 - repoDid?: l.DidString 83 83 - } 79 79 + $type?: "sh.tangled.repo.pull#source"; 80 80 + branch: string; 81 81 + repo?: l.AtUriString; 82 82 + repoDid?: l.DidString; 83 83 + }; 84 84 85 85 - export type { Source } 85 85 + export type { Source }; 86 86 87 87 const source = l.typedObject<Source>( 88 88 $nsid, 89 89 - 'source', 89 89 + "source", 90 90 l.object({ 91 91 branch: l.string(), 92 92 - repo: l.optional(l.string({ format: 'at-uri' })), 93 93 - repoDid: l.optional(l.string({ format: 'did' })), 92 92 + repo: l.optional(l.string({ format: "at-uri" })), 93 93 + repoDid: l.optional(l.string({ format: "did" })), 94 94 }), 95 95 - ) 95 95 + ); 96 96 97 97 - export { source } 97 97 + export { source }; 98 98 99 99 /** revisions of this pull request, newer rounds are appended to this array. appviews may reject records do not treat this field as append-only. the blob format is gzipped text-based git-format-patches. */ 100 100 type Round = { 101 101 - $type?: 'sh.tangled.repo.pull#round' 102 102 - createdAt: l.DatetimeString 103 103 - patchBlob: l.BlobRef 104 104 - } 101 101 + $type?: "sh.tangled.repo.pull#round"; 102 102 + createdAt: l.DatetimeString; 103 103 + patchBlob: l.BlobRef; 104 104 + }; 105 105 106 106 - export type { Round } 106 106 + export type { Round }; 107 107 108 108 /** revisions of this pull request, newer rounds are appended to this array. appviews may reject records do not treat this field as append-only. the blob format is gzipped text-based git-format-patches. */ 109 109 const round = l.typedObject<Round>( 110 110 $nsid, 111 111 - 'round', 111 111 + "round", 112 112 l.object({ 113 113 - createdAt: l.string({ format: 'datetime' }), 114 114 - patchBlob: l.blob({ accept: ['application/gzip'] }), 113 113 + createdAt: l.string({ format: "datetime" }), 114 114 + patchBlob: l.blob({ accept: ["application/gzip"] }), 115 115 }), 116 116 - ) 116 116 + ); 117 117 118 118 - export { round } 118 118 + export { round };

+4 -4

api/src/lexicons/sh/tangled/repo/pull.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * as status from './pull/status.ts' 6 6 - export * as comment from './pull/comment.ts' 7 7 - export * from './pull.defs.ts' 8 8 - export * as $defs from './pull.defs.ts' 5 5 + export * as status from "./pull/status.ts"; 6 6 + export * as comment from "./pull/comment.ts"; 7 7 + export * from "./pull.defs.ts"; 8 8 + export * as $defs from "./pull.defs.ts";

+21 -21

api/src/lexicons/sh/tangled/repo/pull/comment.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.pull.comment' 7 7 + const $nsid = "sh.tangled.repo.pull.comment"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 type Main = { 12 12 - $type: 'sh.tangled.repo.pull.comment' 13 13 - pull: l.AtUriString 14 14 - body: string 15 15 - createdAt: l.DatetimeString 16 16 - mentions?: l.DidString[] 17 17 - references?: l.AtUriString[] 18 18 - } 12 12 + $type: "sh.tangled.repo.pull.comment"; 13 13 + pull: l.AtUriString; 14 14 + body: string; 15 15 + createdAt: l.DatetimeString; 16 16 + mentions?: l.DidString[]; 17 17 + references?: l.AtUriString[]; 18 18 + }; 19 19 20 20 - export type { Main } 20 20 + export type { Main }; 21 21 22 22 - const main = l.record<'tid', Main>( 23 23 - 'tid', 22 22 + const main = l.record<"tid", Main>( 23 23 + "tid", 24 24 $nsid, 25 25 l.object({ 26 26 - pull: l.string({ format: 'at-uri' }), 26 26 + pull: l.string({ format: "at-uri" }), 27 27 body: l.string(), 28 28 - createdAt: l.string({ format: 'datetime' }), 29 29 - mentions: l.optional(l.array(l.string({ format: 'did' }))), 30 30 - references: l.optional(l.array(l.string({ format: 'at-uri' }))), 28 28 + createdAt: l.string({ format: "datetime" }), 29 29 + mentions: l.optional(l.array(l.string({ format: "did" }))), 30 30 + references: l.optional(l.array(l.string({ format: "at-uri" }))), 31 31 }), 32 32 - ) 32 32 + ); 33 33 34 34 - export { main } 34 34 + export { main }; 35 35 36 36 export const $isTypeOf = /*#__PURE__*/ main.isTypeOf.bind(main), 37 37 $build = /*#__PURE__*/ main.build.bind(main), 38 38 - $type = /*#__PURE__*/ main.$type 38 38 + $type = /*#__PURE__*/ main.$type; 39 39 export const $assert = /*#__PURE__*/ main.assert.bind(main), 40 40 $check = /*#__PURE__*/ main.check.bind(main), 41 41 $cast = /*#__PURE__*/ main.cast.bind(main), ··· 44 44 $parse = /*#__PURE__*/ main.parse.bind(main), 45 45 $safeParse = /*#__PURE__*/ main.safeParse.bind(main), 46 46 $validate = /*#__PURE__*/ main.validate.bind(main), 47 47 - $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main) 47 47 + $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main);

+2 -2

api/src/lexicons/sh/tangled/repo/pull/comment.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './comment.defs.ts' 6 6 - export * as $defs from './comment.defs.ts' 5 5 + export * from "./comment.defs.ts"; 6 6 + export * as $defs from "./comment.defs.ts";

+23 -23

api/src/lexicons/sh/tangled/repo/pull/status.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.pull.status' 7 7 + const $nsid = "sh.tangled.repo.pull.status"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 type Main = { 12 12 - $type: 'sh.tangled.repo.pull.status' 13 13 - pull: l.AtUriString 12 12 + $type: "sh.tangled.repo.pull.status"; 13 13 + pull: l.AtUriString; 14 14 15 15 /** 16 16 * status of the pull request 17 17 */ 18 18 status: 19 19 - | 'sh.tangled.repo.pull.status.open' 20 20 - | 'sh.tangled.repo.pull.status.closed' 21 21 - | 'sh.tangled.repo.pull.status.merged' 22 22 - | l.UnknownString 23 23 - } 19 19 + | "sh.tangled.repo.pull.status.open" 20 20 + | "sh.tangled.repo.pull.status.closed" 21 21 + | "sh.tangled.repo.pull.status.merged" 22 22 + | l.UnknownString; 23 23 + }; 24 24 25 25 - export type { Main } 25 25 + export type { Main }; 26 26 27 27 - const main = l.record<'tid', Main>( 28 28 - 'tid', 27 27 + const main = l.record<"tid", Main>( 28 28 + "tid", 29 29 $nsid, 30 30 l.object({ 31 31 - pull: l.string({ format: 'at-uri' }), 31 31 + pull: l.string({ format: "at-uri" }), 32 32 status: l.withDefault( 33 33 l.string<{ 34 34 knownValues: [ 35 35 - 'sh.tangled.repo.pull.status.open', 36 36 - 'sh.tangled.repo.pull.status.closed', 37 37 - 'sh.tangled.repo.pull.status.merged', 38 38 - ] 35 35 + "sh.tangled.repo.pull.status.open", 36 36 + "sh.tangled.repo.pull.status.closed", 37 37 + "sh.tangled.repo.pull.status.merged", 38 38 + ]; 39 39 }>(), 40 40 - 'sh.tangled.repo.pull.status.open', 40 40 + "sh.tangled.repo.pull.status.open", 41 41 ), 42 42 }), 43 43 - ) 43 43 + ); 44 44 45 45 - export { main } 45 45 + export { main }; 46 46 47 47 export const $isTypeOf = /*#__PURE__*/ main.isTypeOf.bind(main), 48 48 $build = /*#__PURE__*/ main.build.bind(main), 49 49 - $type = /*#__PURE__*/ main.$type 49 49 + $type = /*#__PURE__*/ main.$type; 50 50 export const $assert = /*#__PURE__*/ main.assert.bind(main), 51 51 $check = /*#__PURE__*/ main.check.bind(main), 52 52 $cast = /*#__PURE__*/ main.cast.bind(main), ··· 55 55 $parse = /*#__PURE__*/ main.parse.bind(main), 56 56 $safeParse = /*#__PURE__*/ main.safeParse.bind(main), 57 57 $validate = /*#__PURE__*/ main.validate.bind(main), 58 58 - $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main) 58 58 + $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main);

+5 -5

api/src/lexicons/sh/tangled/repo/pull/status.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * as closed from './status/closed.ts' 6 6 - export * as merged from './status/merged.ts' 7 7 - export * as open from './status/open.ts' 8 8 - export * from './status.defs.ts' 9 9 - export * as $defs from './status.defs.ts' 5 5 + export * as closed from "./status/closed.ts"; 6 6 + export * as merged from "./status/merged.ts"; 7 7 + export * as open from "./status/open.ts"; 8 8 + export * from "./status.defs.ts"; 9 9 + export * as $defs from "./status.defs.ts";

+8 -8

api/src/lexicons/sh/tangled/repo/pull/status/closed.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.pull.status.closed' 7 7 + const $nsid = "sh.tangled.repo.pull.status.closed"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 /** closed pull request */ 12 12 - type Main = 'sh.tangled.repo.pull.status.closed' 12 12 + type Main = "sh.tangled.repo.pull.status.closed"; 13 13 14 14 - export type { Main } 14 14 + export type { Main }; 15 15 16 16 /** closed pull request */ 17 17 - const main = l.token($nsid, 'main') 17 17 + const main = l.token($nsid, "main"); 18 18 19 19 - export { main } 19 19 + export { main }; 20 20 21 21 export const $assert = /*#__PURE__*/ main.assert.bind(main), 22 22 $check = /*#__PURE__*/ main.check.bind(main), ··· 26 26 $parse = /*#__PURE__*/ main.parse.bind(main), 27 27 $safeParse = /*#__PURE__*/ main.safeParse.bind(main), 28 28 $validate = /*#__PURE__*/ main.validate.bind(main), 29 29 - $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main) 29 29 + $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main);

+2 -2

api/src/lexicons/sh/tangled/repo/pull/status/closed.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './closed.defs.ts' 6 6 - export * as $defs from './closed.defs.ts' 5 5 + export * from "./closed.defs.ts"; 6 6 + export * as $defs from "./closed.defs.ts";

+8 -8

api/src/lexicons/sh/tangled/repo/pull/status/merged.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.pull.status.merged' 7 7 + const $nsid = "sh.tangled.repo.pull.status.merged"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 /** merged pull request */ 12 12 - type Main = 'sh.tangled.repo.pull.status.merged' 12 12 + type Main = "sh.tangled.repo.pull.status.merged"; 13 13 14 14 - export type { Main } 14 14 + export type { Main }; 15 15 16 16 /** merged pull request */ 17 17 - const main = l.token($nsid, 'main') 17 17 + const main = l.token($nsid, "main"); 18 18 19 19 - export { main } 19 19 + export { main }; 20 20 21 21 export const $assert = /*#__PURE__*/ main.assert.bind(main), 22 22 $check = /*#__PURE__*/ main.check.bind(main), ··· 26 26 $parse = /*#__PURE__*/ main.parse.bind(main), 27 27 $safeParse = /*#__PURE__*/ main.safeParse.bind(main), 28 28 $validate = /*#__PURE__*/ main.validate.bind(main), 29 29 - $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main) 29 29 + $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main);

+2 -2

api/src/lexicons/sh/tangled/repo/pull/status/merged.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './merged.defs.ts' 6 6 - export * as $defs from './merged.defs.ts' 5 5 + export * from "./merged.defs.ts"; 6 6 + export * as $defs from "./merged.defs.ts";

+8 -8

api/src/lexicons/sh/tangled/repo/pull/status/open.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.pull.status.open' 7 7 + const $nsid = "sh.tangled.repo.pull.status.open"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 /** open pull request */ 12 12 - type Main = 'sh.tangled.repo.pull.status.open' 12 12 + type Main = "sh.tangled.repo.pull.status.open"; 13 13 14 14 - export type { Main } 14 14 + export type { Main }; 15 15 16 16 /** open pull request */ 17 17 - const main = l.token($nsid, 'main') 17 17 + const main = l.token($nsid, "main"); 18 18 19 19 - export { main } 19 19 + export { main }; 20 20 21 21 export const $assert = /*#__PURE__*/ main.assert.bind(main), 22 22 $check = /*#__PURE__*/ main.check.bind(main), ··· 26 26 $parse = /*#__PURE__*/ main.parse.bind(main), 27 27 $safeParse = /*#__PURE__*/ main.safeParse.bind(main), 28 28 $validate = /*#__PURE__*/ main.validate.bind(main), 29 29 - $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main) 29 29 + $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main);

+2 -2

api/src/lexicons/sh/tangled/repo/pull/status/open.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './open.defs.ts' 6 6 - export * as $defs from './open.defs.ts' 5 5 + export * from "./open.defs.ts"; 6 6 + export * as $defs from "./open.defs.ts";

+12 -18

api/src/lexicons/sh/tangled/repo/removeSecret.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.removeSecret' 7 7 + const $nsid = "sh.tangled.repo.removeSecret"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 /** Remove a CI secret */ 12 12 const main = l.procedure( 13 13 $nsid, 14 14 l.params(), 15 15 l.jsonPayload({ 16 16 - repo: l.string({ format: 'at-uri' }), 16 16 + repo: l.string({ format: "at-uri" }), 17 17 key: l.string({ maxLength: 50, minLength: 1 }), 18 18 }), 19 19 l.payload(), 20 20 - ) 21 21 - export { main } 20 20 + ); 21 21 + export { main }; 22 22 23 23 - export type $Params = l.InferMethodParams<typeof main> 24 24 - export type $Input<B = l.BinaryData> = l.InferMethodInput<typeof main, B> 25 25 - export type $InputBody<B = l.BinaryData> = l.InferMethodInputBody< 26 26 - typeof main, 27 27 - B 28 28 - > 29 29 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 30 30 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 31 31 - typeof main, 32 32 - B 33 33 - > 23 23 + export type $Params = l.InferMethodParams<typeof main>; 24 24 + export type $Input<B = l.BinaryData> = l.InferMethodInput<typeof main, B>; 25 25 + export type $InputBody<B = l.BinaryData> = l.InferMethodInputBody<typeof main, B>; 26 26 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 27 27 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 34 28 35 29 export const $lxm = main.nsid, 36 30 $params = main.parameters, 37 31 $input = main.input, 38 38 - $output = main.output 32 32 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/repo/removeSecret.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './removeSecret.defs.ts' 6 6 - export * as $defs from './removeSecret.defs.ts' 5 5 + export * from "./removeSecret.defs.ts"; 6 6 + export * as $defs from "./removeSecret.defs.ts";

+12 -18

api/src/lexicons/sh/tangled/repo/setDefaultBranch.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.setDefaultBranch' 7 7 + const $nsid = "sh.tangled.repo.setDefaultBranch"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 /** Set the default branch for a repository */ 12 12 const main = l.procedure( 13 13 $nsid, 14 14 l.params(), 15 15 l.jsonPayload({ 16 16 - repo: l.string({ format: 'at-uri' }), 16 16 + repo: l.string({ format: "at-uri" }), 17 17 defaultBranch: l.string(), 18 18 }), 19 19 l.payload(), 20 20 - ) 21 21 - export { main } 20 20 + ); 21 21 + export { main }; 22 22 23 23 - export type $Params = l.InferMethodParams<typeof main> 24 24 - export type $Input<B = l.BinaryData> = l.InferMethodInput<typeof main, B> 25 25 - export type $InputBody<B = l.BinaryData> = l.InferMethodInputBody< 26 26 - typeof main, 27 27 - B 28 28 - > 29 29 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 30 30 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 31 31 - typeof main, 32 32 - B 33 33 - > 23 23 + export type $Params = l.InferMethodParams<typeof main>; 24 24 + export type $Input<B = l.BinaryData> = l.InferMethodInput<typeof main, B>; 25 25 + export type $InputBody<B = l.BinaryData> = l.InferMethodInputBody<typeof main, B>; 26 26 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 27 27 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 34 28 35 29 export const $lxm = main.nsid, 36 30 $params = main.parameters, 37 31 $input = main.input, 38 38 - $output = main.output 32 32 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/repo/setDefaultBranch.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './setDefaultBranch.defs.ts' 6 6 - export * as $defs from './setDefaultBranch.defs.ts' 5 5 + export * from "./setDefaultBranch.defs.ts"; 6 6 + export * as $defs from "./setDefaultBranch.defs.ts";

+13 -17

api/src/lexicons/sh/tangled/repo/tag.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.tag' 7 7 + const $nsid = "sh.tangled.repo.tag"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 - const main = l.query( 12 12 - $nsid, 13 13 - l.params({ repo: l.string(), tag: l.string() }), 14 14 - l.payload('*/*'), 15 15 - ['RepoNotFound', 'TagNotFound', 'InvalidRequest'], 16 16 - ) 17 17 - export { main } 11 11 + const main = l.query($nsid, l.params({ repo: l.string(), tag: l.string() }), l.payload("*/*"), [ 12 12 + "RepoNotFound", 13 13 + "TagNotFound", 14 14 + "InvalidRequest", 15 15 + ]); 16 16 + export { main }; 18 17 19 19 - export type $Params = l.InferMethodParams<typeof main> 20 20 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 21 21 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 22 22 - typeof main, 23 23 - B 24 24 - > 18 18 + export type $Params = l.InferMethodParams<typeof main>; 19 19 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 20 20 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 25 21 26 22 export const $lxm = main.nsid, 27 23 $params = main.parameters, 28 28 - $output = main.output 24 24 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/repo/tag.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './tag.defs.ts' 6 6 - export * as $defs from './tag.defs.ts' 5 5 + export * from "./tag.defs.ts"; 6 6 + export * as $defs from "./tag.defs.ts";

+12 -17

api/src/lexicons/sh/tangled/repo/tags.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.tags' 7 7 + const $nsid = "sh.tangled.repo.tags"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 const main = l.query( 12 12 $nsid, 13 13 l.params({ 14 14 repo: l.string(), 15 15 - limit: l.optional( 16 16 - l.withDefault(l.integer({ minimum: 1, maximum: 100 }), 50), 17 17 - ), 15 15 + limit: l.optional(l.withDefault(l.integer({ minimum: 1, maximum: 100 }), 50)), 18 16 cursor: l.optional(l.string()), 19 17 }), 20 20 - l.payload('*/*'), 21 21 - ['RepoNotFound', 'InvalidRequest'], 22 22 - ) 23 23 - export { main } 18 18 + l.payload("*/*"), 19 19 + ["RepoNotFound", "InvalidRequest"], 20 20 + ); 21 21 + export { main }; 24 22 25 25 - export type $Params = l.InferMethodParams<typeof main> 26 26 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 27 27 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 28 28 - typeof main, 29 29 - B 30 30 - > 23 23 + export type $Params = l.InferMethodParams<typeof main>; 24 24 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 25 25 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 31 26 32 27 export const $lxm = main.nsid, 33 28 $params = main.parameters, 34 34 - $output = main.output 29 29 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/repo/tags.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './tags.defs.ts' 6 6 - export * as $defs from './tags.defs.ts' 5 5 + export * from "./tags.defs.ts"; 6 6 + export * as $defs from "./tags.defs.ts";

+50 -53

api/src/lexicons/sh/tangled/repo/tree.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.repo.tree' 7 7 + const $nsid = "sh.tangled.repo.tree"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 const main = l.query( 12 12 $nsid, 13 13 l.params({ 14 14 repo: l.string(), 15 15 ref: l.string(), 16 16 - path: l.optional(l.withDefault(l.string(), '')), 16 16 + path: l.optional(l.withDefault(l.string(), "")), 17 17 }), 18 18 l.jsonPayload({ 19 19 ref: l.string(), ··· 23 23 lastCommit: l.optional(l.ref<LastCommit>((() => lastCommit) as any)), 24 24 files: l.array(l.ref<TreeEntry>((() => treeEntry) as any)), 25 25 }), 26 26 - ['RepoNotFound', 'RefNotFound', 'PathNotFound', 'InvalidRequest'], 27 27 - ) 28 28 - export { main } 26 26 + ["RepoNotFound", "RefNotFound", "PathNotFound", "InvalidRequest"], 27 27 + ); 28 28 + export { main }; 29 29 30 30 - export type $Params = l.InferMethodParams<typeof main> 31 31 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 32 32 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 33 33 - typeof main, 34 34 - B 35 35 - > 30 30 + export type $Params = l.InferMethodParams<typeof main>; 31 31 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 32 32 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 36 33 37 34 export const $lxm = main.nsid, 38 35 $params = main.parameters, 39 39 - $output = main.output 36 36 + $output = main.output; 40 37 41 38 type Readme = { 42 42 - $type?: 'sh.tangled.repo.tree#readme' 39 39 + $type?: "sh.tangled.repo.tree#readme"; 43 40 44 41 /** 45 42 * Name of the readme file 46 43 */ 47 47 - filename: string 44 44 + filename: string; 48 45 49 46 /** 50 47 * Contents of the readme file 51 48 */ 52 52 - contents: string 53 53 - } 49 49 + contents: string; 50 50 + }; 54 51 55 55 - export type { Readme } 52 52 + export type { Readme }; 56 53 57 54 const readme = l.typedObject<Readme>( 58 55 $nsid, 59 59 - 'readme', 56 56 + "readme", 60 57 l.object({ filename: l.string(), contents: l.string() }), 61 61 - ) 58 58 + ); 62 59 63 63 - export { readme } 60 60 + export { readme }; 64 61 65 62 type TreeEntry = { 66 66 - $type?: 'sh.tangled.repo.tree#treeEntry' 63 63 + $type?: "sh.tangled.repo.tree#treeEntry"; 67 64 68 65 /** 69 66 * Relative file or directory name 70 67 */ 71 71 - name: string 68 68 + name: string; 72 69 73 70 /** 74 71 * File mode 75 72 */ 76 76 - mode: string 73 73 + mode: string; 77 74 78 75 /** 79 76 * File size in bytes 80 77 */ 81 81 - size: number 82 82 - last_commit?: LastCommit 83 83 - } 78 78 + size: number; 79 79 + last_commit?: LastCommit; 80 80 + }; 84 81 85 85 - export type { TreeEntry } 82 82 + export type { TreeEntry }; 86 83 87 84 const treeEntry = l.typedObject<TreeEntry>( 88 85 $nsid, 89 89 - 'treeEntry', 86 86 + "treeEntry", 90 87 l.object({ 91 88 name: l.string(), 92 89 mode: l.string(), 93 90 size: l.integer(), 94 91 last_commit: l.optional(l.ref<LastCommit>((() => lastCommit) as any)), 95 92 }), 96 96 - ) 93 93 + ); 97 94 98 98 - export { treeEntry } 95 95 + export { treeEntry }; 99 96 100 97 type LastCommit = { 101 101 - $type?: 'sh.tangled.repo.tree#lastCommit' 98 98 + $type?: "sh.tangled.repo.tree#lastCommit"; 102 99 103 100 /** 104 101 * Commit hash 105 102 */ 106 106 - hash: string 103 103 + hash: string; 107 104 108 105 /** 109 106 * Commit message 110 107 */ 111 111 - message: string 112 112 - author?: Signature 108 108 + message: string; 109 109 + author?: Signature; 113 110 114 111 /** 115 112 * Commit timestamp 116 113 */ 117 117 - when: l.DatetimeString 118 118 - } 114 114 + when: l.DatetimeString; 115 115 + }; 119 116 120 120 - export type { LastCommit } 117 117 + export type { LastCommit }; 121 118 122 119 const lastCommit = l.typedObject<LastCommit>( 123 120 $nsid, 124 124 - 'lastCommit', 121 121 + "lastCommit", 125 122 l.object({ 126 123 hash: l.string(), 127 124 message: l.string(), 128 125 author: l.optional(l.ref<Signature>((() => signature) as any)), 129 129 - when: l.string({ format: 'datetime' }), 126 126 + when: l.string({ format: "datetime" }), 130 127 }), 131 131 - ) 128 128 + ); 132 129 133 133 - export { lastCommit } 130 130 + export { lastCommit }; 134 131 135 132 type Signature = { 136 136 - $type?: 'sh.tangled.repo.tree#signature' 133 133 + $type?: "sh.tangled.repo.tree#signature"; 137 134 138 135 /** 139 136 * Author name 140 137 */ 141 141 - name: string 138 138 + name: string; 142 139 143 140 /** 144 141 * Author email 145 142 */ 146 146 - email: string 143 143 + email: string; 147 144 148 145 /** 149 146 * Author timestamp 150 147 */ 151 151 - when: l.DatetimeString 152 152 - } 148 148 + when: l.DatetimeString; 149 149 + }; 153 150 154 154 - export type { Signature } 151 151 + export type { Signature }; 155 152 156 153 const signature = l.typedObject<Signature>( 157 154 $nsid, 158 158 - 'signature', 155 155 + "signature", 159 156 l.object({ 160 157 name: l.string(), 161 158 email: l.string(), 162 162 - when: l.string({ format: 'datetime' }), 159 159 + when: l.string({ format: "datetime" }), 163 160 }), 164 164 - ) 161 161 + ); 165 162 166 166 - export { signature } 163 163 + export { signature };

+2 -2

api/src/lexicons/sh/tangled/repo/tree.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './tree.defs.ts' 6 6 - export * as $defs from './tree.defs.ts' 5 5 + export * from "./tree.defs.ts"; 6 6 + export * as $defs from "./tree.defs.ts";

+12 -12

api/src/lexicons/sh/tangled/spindle.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.spindle' 7 7 + const $nsid = "sh.tangled.spindle"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 - type Main = { $type: 'sh.tangled.spindle'; createdAt: l.DatetimeString } 11 11 + type Main = { $type: "sh.tangled.spindle"; createdAt: l.DatetimeString }; 12 12 13 13 - export type { Main } 13 13 + export type { Main }; 14 14 15 15 - const main = l.record<'any', Main>( 16 16 - 'any', 15 15 + const main = l.record<"any", Main>( 16 16 + "any", 17 17 $nsid, 18 18 - l.object({ createdAt: l.string({ format: 'datetime' }) }), 19 19 - ) 18 18 + l.object({ createdAt: l.string({ format: "datetime" }) }), 19 19 + ); 20 20 21 21 - export { main } 21 21 + export { main }; 22 22 23 23 export const $isTypeOf = /*#__PURE__*/ main.isTypeOf.bind(main), 24 24 $build = /*#__PURE__*/ main.build.bind(main), 25 25 - $type = /*#__PURE__*/ main.$type 25 25 + $type = /*#__PURE__*/ main.$type; 26 26 export const $assert = /*#__PURE__*/ main.assert.bind(main), 27 27 $check = /*#__PURE__*/ main.check.bind(main), 28 28 $cast = /*#__PURE__*/ main.cast.bind(main), ··· 31 31 $parse = /*#__PURE__*/ main.parse.bind(main), 32 32 $safeParse = /*#__PURE__*/ main.safeParse.bind(main), 33 33 $validate = /*#__PURE__*/ main.validate.bind(main), 34 34 - $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main) 34 34 + $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main);

+3 -3

api/src/lexicons/sh/tangled/spindle.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * as member from './spindle/member.ts' 6 6 - export * from './spindle.defs.ts' 7 7 - export * as $defs from './spindle.defs.ts' 5 5 + export * as member from "./spindle/member.ts"; 6 6 + export * from "./spindle.defs.ts"; 7 7 + export * as $defs from "./spindle.defs.ts";

+17 -17

api/src/lexicons/sh/tangled/spindle/member.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.spindle.member' 7 7 + const $nsid = "sh.tangled.spindle.member"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 type Main = { 12 12 - $type: 'sh.tangled.spindle.member' 13 13 - subject: l.DidString 12 12 + $type: "sh.tangled.spindle.member"; 13 13 + subject: l.DidString; 14 14 15 15 /** 16 16 * spindle instance that the subject is now a member of 17 17 */ 18 18 - instance: string 19 19 - createdAt: l.DatetimeString 20 20 - } 18 18 + instance: string; 19 19 + createdAt: l.DatetimeString; 20 20 + }; 21 21 22 22 - export type { Main } 22 22 + export type { Main }; 23 23 24 24 - const main = l.record<'tid', Main>( 25 25 - 'tid', 24 24 + const main = l.record<"tid", Main>( 25 25 + "tid", 26 26 $nsid, 27 27 l.object({ 28 28 - subject: l.string({ format: 'did' }), 28 28 + subject: l.string({ format: "did" }), 29 29 instance: l.string(), 30 30 - createdAt: l.string({ format: 'datetime' }), 30 30 + createdAt: l.string({ format: "datetime" }), 31 31 }), 32 32 - ) 32 32 + ); 33 33 34 34 - export { main } 34 34 + export { main }; 35 35 36 36 export const $isTypeOf = /*#__PURE__*/ main.isTypeOf.bind(main), 37 37 $build = /*#__PURE__*/ main.build.bind(main), 38 38 - $type = /*#__PURE__*/ main.$type 38 38 + $type = /*#__PURE__*/ main.$type; 39 39 export const $assert = /*#__PURE__*/ main.assert.bind(main), 40 40 $check = /*#__PURE__*/ main.check.bind(main), 41 41 $cast = /*#__PURE__*/ main.cast.bind(main), ··· 44 44 $parse = /*#__PURE__*/ main.parse.bind(main), 45 45 $safeParse = /*#__PURE__*/ main.safeParse.bind(main), 46 46 $validate = /*#__PURE__*/ main.validate.bind(main), 47 47 - $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main) 47 47 + $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main);

+2 -2

api/src/lexicons/sh/tangled/spindle/member.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './member.defs.ts' 6 6 - export * as $defs from './member.defs.ts' 5 5 + export * from "./member.defs.ts"; 6 6 + export * as $defs from "./member.defs.ts";

+17 -17

api/src/lexicons/sh/tangled/string.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.string' 7 7 + const $nsid = "sh.tangled.string"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 type Main = { 12 12 - $type: 'sh.tangled.string' 13 13 - filename: string 14 14 - description: string 15 15 - createdAt: l.DatetimeString 16 16 - contents: string 17 17 - } 12 12 + $type: "sh.tangled.string"; 13 13 + filename: string; 14 14 + description: string; 15 15 + createdAt: l.DatetimeString; 16 16 + contents: string; 17 17 + }; 18 18 19 19 - export type { Main } 19 19 + export type { Main }; 20 20 21 21 - const main = l.record<'tid', Main>( 22 22 - 'tid', 21 21 + const main = l.record<"tid", Main>( 22 22 + "tid", 23 23 $nsid, 24 24 l.object({ 25 25 filename: l.string({ maxGraphemes: 140, minGraphemes: 1 }), 26 26 description: l.string({ maxGraphemes: 280 }), 27 27 - createdAt: l.string({ format: 'datetime' }), 27 27 + createdAt: l.string({ format: "datetime" }), 28 28 contents: l.string({ minGraphemes: 1 }), 29 29 }), 30 30 - ) 30 30 + ); 31 31 32 32 - export { main } 32 32 + export { main }; 33 33 34 34 export const $isTypeOf = /*#__PURE__*/ main.isTypeOf.bind(main), 35 35 $build = /*#__PURE__*/ main.build.bind(main), 36 36 - $type = /*#__PURE__*/ main.$type 36 36 + $type = /*#__PURE__*/ main.$type; 37 37 export const $assert = /*#__PURE__*/ main.assert.bind(main), 38 38 $check = /*#__PURE__*/ main.check.bind(main), 39 39 $cast = /*#__PURE__*/ main.cast.bind(main), ··· 42 42 $parse = /*#__PURE__*/ main.parse.bind(main), 43 43 $safeParse = /*#__PURE__*/ main.safeParse.bind(main), 44 44 $validate = /*#__PURE__*/ main.validate.bind(main), 45 45 - $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main) 45 45 + $safeValidate = /*#__PURE__*/ main.safeValidate.bind(main);

+2 -2

api/src/lexicons/sh/tangled/string.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './string.defs.ts' 6 6 - export * as $defs from './string.defs.ts' 5 5 + export * from "./string.defs.ts"; 6 6 + export * as $defs from "./string.defs.ts";

+1 -1

api/src/lexicons/sh/tangled/sync.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * as requestCrawl from './sync/requestCrawl.ts' 5 5 + export * as requestCrawl from "./sync/requestCrawl.ts";

+13 -19

api/src/lexicons/sh/tangled/sync/requestCrawl.defs.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - import { l } from '@atproto/lex' 5 5 + import { l } from "@atproto/lex"; 6 6 7 7 - const $nsid = 'sh.tangled.sync.requestCrawl' 7 7 + const $nsid = "sh.tangled.sync.requestCrawl"; 8 8 9 9 - export { $nsid } 9 9 + export { $nsid }; 10 10 11 11 /** Request a service to persistently crawl hosted repos. Does not require auth. */ 12 12 const main = l.procedure( ··· 14 14 l.params(), 15 15 l.jsonPayload({ 16 16 hostname: l.string(), 17 17 - ensureRepo: l.optional(l.string({ format: 'at-uri' })), 17 17 + ensureRepo: l.optional(l.string({ format: "at-uri" })), 18 18 }), 19 19 l.payload(), 20 20 - ['HostBanned'], 21 21 - ) 22 22 - export { main } 20 20 + ["HostBanned"], 21 21 + ); 22 22 + export { main }; 23 23 24 24 - export type $Params = l.InferMethodParams<typeof main> 25 25 - export type $Input<B = l.BinaryData> = l.InferMethodInput<typeof main, B> 26 26 - export type $InputBody<B = l.BinaryData> = l.InferMethodInputBody< 27 27 - typeof main, 28 28 - B 29 29 - > 30 30 - export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B> 31 31 - export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody< 32 32 - typeof main, 33 33 - B 34 34 - > 24 24 + export type $Params = l.InferMethodParams<typeof main>; 25 25 + export type $Input<B = l.BinaryData> = l.InferMethodInput<typeof main, B>; 26 26 + export type $InputBody<B = l.BinaryData> = l.InferMethodInputBody<typeof main, B>; 27 27 + export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>; 28 28 + export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>; 35 29 36 30 export const $lxm = main.nsid, 37 31 $params = main.parameters, 38 32 $input = main.input, 39 39 - $output = main.output 33 33 + $output = main.output;

+2 -2

api/src/lexicons/sh/tangled/sync/requestCrawl.ts

reviewed

··· 2 2 * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT. 3 3 */ 4 4 5 5 - export * from './requestCrawl.defs.ts' 6 6 - export * as $defs from './requestCrawl.defs.ts' 5 5 + export * from "./requestCrawl.defs.ts"; 6 6 + export * as $defs from "./requestCrawl.defs.ts";

-1

api/src/lib/id.ts

reviewed

··· 4 4 export type UuidString = `${string}-${string}-7${string}-${string}-${string}`; 5 5 export type Id<For extends string> = UuidString & BRAND<`${For}.id`>; 6 6 7 7 - 8 7 export function parseId<T extends Id<string>>(value: string): T { 9 8 if (!validate(value)) { 10 9 throw new Error(`Invalid UUIDv7: ${value}`);

+1 -1

db/package.json

reviewed

··· 1 1 { 2 2 - "private": true, 3 2 "name": "db", 3 3 + "private": true, 4 4 "scripts": { 5 5 "dev": "./dev.sh" 6 6 }

+4

package.json

reviewed

··· 1 1 { 2 2 "scripts": { 3 3 + "all": "oxfmt", 3 4 "dev": "pnpm i && pnpm -r --parallel run dev", 4 5 "db:generate": "pnpm --filter api db:generate", 5 6 "db:migrate": "pnpm --filter api db:migrate", 6 7 "db:studio": "pnpm --filter api db:studio" 8 8 + }, 9 9 + "devDependencies": { 10 10 + "oxfmt": "^0.47.0" 7 11 } 8 12 }

+219 -1

pnpm-lock.yaml

reviewed

··· 9 9 10 10 importers: 11 11 12 12 - .: {} 12 12 + .: 13 13 + devDependencies: 14 14 + oxfmt: 15 15 + specifier: ^0.47.0 16 16 + version: 0.47.0 13 17 14 18 api: 15 19 dependencies: ··· 622 626 resolution: {integrity: sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A==, tarball: https://registry.npmjs.org/@noble/hashes/-/hashes-1.8.0.tgz} 623 627 engines: {node: ^14.21.3 || >=16} 624 628 629 629 + '@oxfmt/binding-android-arm-eabi@0.47.0': 630 630 + resolution: {integrity: sha512-KrMQRdMi/upr81qT4ijK6X6BNp6jqpMY7FwILQnwIy9QLc3qpnhUx5rsCLGzn4ewsCQ0CNAspN2ogmP1GXLyLw==, tarball: https://registry.npmjs.org/@oxfmt/binding-android-arm-eabi/-/binding-android-arm-eabi-0.47.0.tgz} 631 631 + engines: {node: ^20.19.0 || >=22.12.0} 632 632 + cpu: [arm] 633 633 + os: [android] 634 634 + 635 635 + '@oxfmt/binding-android-arm64@0.47.0': 636 636 + resolution: {integrity: sha512-r4ixS/PeUpAFKgrpDoZ5pSkthjZzVzKd95525Aazj+aOv9H4ulK5zYHGb7wFY5n5kZxHK8TbOJUZgoEb1ohddQ==, tarball: https://registry.npmjs.org/@oxfmt/binding-android-arm64/-/binding-android-arm64-0.47.0.tgz} 637 637 + engines: {node: ^20.19.0 || >=22.12.0} 638 638 + cpu: [arm64] 639 639 + os: [android] 640 640 + 641 641 + '@oxfmt/binding-darwin-arm64@0.47.0': 642 642 + resolution: {integrity: sha512-CLWxiKpMl+195cm09CuaWEhJK0CirRkoMa07aR9+9AFPat2LfIKtwx1JqxZM0MTvcMe6+adlJNdVL6jdInvq3g==, tarball: https://registry.npmjs.org/@oxfmt/binding-darwin-arm64/-/binding-darwin-arm64-0.47.0.tgz} 643 643 + engines: {node: ^20.19.0 || >=22.12.0} 644 644 + cpu: [arm64] 645 645 + os: [darwin] 646 646 + 647 647 + '@oxfmt/binding-darwin-x64@0.47.0': 648 648 + resolution: {integrity: sha512-Xq5fjTYDC50faUeLSm0rZdBqoTgleXEdD7NpJdARtQIczkCJn3xNjMUSQQkUmh4CtxkKTNL68lytcOK3e/osgg==, tarball: https://registry.npmjs.org/@oxfmt/binding-darwin-x64/-/binding-darwin-x64-0.47.0.tgz} 649 649 + engines: {node: ^20.19.0 || >=22.12.0} 650 650 + cpu: [x64] 651 651 + os: [darwin] 652 652 + 653 653 + '@oxfmt/binding-freebsd-x64@0.47.0': 654 654 + resolution: {integrity: sha512-QOU9ZIJ52p5askcEC0QJvvr8trHAWoonul8bgISo6gYUL3s50zkqafBYcNAr9LJZQbsZtPfIWHk9+5+nUp1qJQ==, tarball: https://registry.npmjs.org/@oxfmt/binding-freebsd-x64/-/binding-freebsd-x64-0.47.0.tgz} 655 655 + engines: {node: ^20.19.0 || >=22.12.0} 656 656 + cpu: [x64] 657 657 + os: [freebsd] 658 658 + 659 659 + '@oxfmt/binding-linux-arm-gnueabihf@0.47.0': 660 660 + resolution: {integrity: sha512-oJxDM1aBhPvz9gmElBv8UpxyiqhwfjcbrSxT5F0xtuUzY6dQI27/AQPIt3eu3Z5Yvn0kQl5R7MA3Z+MbnRvCBw==, tarball: https://registry.npmjs.org/@oxfmt/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-0.47.0.tgz} 661 661 + engines: {node: ^20.19.0 || >=22.12.0} 662 662 + cpu: [arm] 663 663 + os: [linux] 664 664 + 665 665 + '@oxfmt/binding-linux-arm-musleabihf@0.47.0': 666 666 + resolution: {integrity: sha512-g8Lh50VS4ibGz2q6v7r9UZY4D0dM16SdrFYOMzhqIoCwGcai8VMIRUAcqn1/jlCsOOzUXJ741+kCeJt0cofakQ==, tarball: https://registry.npmjs.org/@oxfmt/binding-linux-arm-musleabihf/-/binding-linux-arm-musleabihf-0.47.0.tgz} 667 667 + engines: {node: ^20.19.0 || >=22.12.0} 668 668 + cpu: [arm] 669 669 + os: [linux] 670 670 + 671 671 + '@oxfmt/binding-linux-arm64-gnu@0.47.0': 672 672 + resolution: {integrity: sha512-YrNT1vQ0asaXoRbrvYENPqmBfOQ9Xr8enPNOULeYfg44VjCcrUowFy5QZr+WawE0zyP8cH9e9Gxxg0fDEFzhcg==, tarball: https://registry.npmjs.org/@oxfmt/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-0.47.0.tgz} 673 673 + engines: {node: ^20.19.0 || >=22.12.0} 674 674 + cpu: [arm64] 675 675 + os: [linux] 676 676 + libc: [glibc] 677 677 + 678 678 + '@oxfmt/binding-linux-arm64-musl@0.47.0': 679 679 + resolution: {integrity: sha512-IxtQC/sbBi4ubbY+MdwdanRWrG9InQJVZqyMsBa5IUaQcnSg86gQme574HxXMC1p4bo4YhV99zQ+wNnGCvEgzw==, tarball: https://registry.npmjs.org/@oxfmt/binding-linux-arm64-musl/-/binding-linux-arm64-musl-0.47.0.tgz} 680 680 + engines: {node: ^20.19.0 || >=22.12.0} 681 681 + cpu: [arm64] 682 682 + os: [linux] 683 683 + libc: [musl] 684 684 + 685 685 + '@oxfmt/binding-linux-ppc64-gnu@0.47.0': 686 686 + resolution: {integrity: sha512-EWXEhOMbWO0q6eJSbu0QLkU8cKi0ljlYLngeDs2Ocu/pm1rrLwyQiYzlFbdnMRURI4w9ndr1sI9rSbhlJ5o23Q==, tarball: https://registry.npmjs.org/@oxfmt/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-0.47.0.tgz} 687 687 + engines: {node: ^20.19.0 || >=22.12.0} 688 688 + cpu: [ppc64] 689 689 + os: [linux] 690 690 + libc: [glibc] 691 691 + 692 692 + '@oxfmt/binding-linux-riscv64-gnu@0.47.0': 693 693 + resolution: {integrity: sha512-tZrjS11TUiDuEpRaqdk8K9F9xETRyKXfuZKmdeW+Gj7coBnm7+8sBEfyt033EAFEQSlkniAXvBLh+Qja2ioGBQ==, tarball: https://registry.npmjs.org/@oxfmt/binding-linux-riscv64-gnu/-/binding-linux-riscv64-gnu-0.47.0.tgz} 694 694 + engines: {node: ^20.19.0 || >=22.12.0} 695 695 + cpu: [riscv64] 696 696 + os: [linux] 697 697 + libc: [glibc] 698 698 + 699 699 + '@oxfmt/binding-linux-riscv64-musl@0.47.0': 700 700 + resolution: {integrity: sha512-KBFy+2CFKUCZzYwX2ZOPQKck1vjQbz+hextuc19G4r0WRJwadfAeuQMQRQvB+Ivc8brlbOVg7et8K7E467440g==, tarball: https://registry.npmjs.org/@oxfmt/binding-linux-riscv64-musl/-/binding-linux-riscv64-musl-0.47.0.tgz} 701 701 + engines: {node: ^20.19.0 || >=22.12.0} 702 702 + cpu: [riscv64] 703 703 + os: [linux] 704 704 + libc: [musl] 705 705 + 706 706 + '@oxfmt/binding-linux-s390x-gnu@0.47.0': 707 707 + resolution: {integrity: sha512-REUPFKVGSiK99B+9eaPhluEVglzaoj/SMykNC5SUiV2RSsBfV5lWN7Y0iCIc251Wz3GaeAGZsJ/zj3gjarxdFg==, tarball: https://registry.npmjs.org/@oxfmt/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-0.47.0.tgz} 708 708 + engines: {node: ^20.19.0 || >=22.12.0} 709 709 + cpu: [s390x] 710 710 + os: [linux] 711 711 + libc: [glibc] 712 712 + 713 713 + '@oxfmt/binding-linux-x64-gnu@0.47.0': 714 714 + resolution: {integrity: sha512-KVftVSVEDeIfRW3TIeLe3aNI/iY4m1fu5mDwHcisKMZSCMKLkrhFsjowC7o9RoqNPxbbglm2+/6KAKBIts2t0Q==, tarball: https://registry.npmjs.org/@oxfmt/binding-linux-x64-gnu/-/binding-linux-x64-gnu-0.47.0.tgz} 715 715 + engines: {node: ^20.19.0 || >=22.12.0} 716 716 + cpu: [x64] 717 717 + os: [linux] 718 718 + libc: [glibc] 719 719 + 720 720 + '@oxfmt/binding-linux-x64-musl@0.47.0': 721 721 + resolution: {integrity: sha512-DTsmGEaA2860Aq5VUyDO8/MT9NFxwVL93RnRYmpMwK6DsSkThmvEpqoUDDljziEpAedMRG19SCogrNbINSbLUQ==, tarball: https://registry.npmjs.org/@oxfmt/binding-linux-x64-musl/-/binding-linux-x64-musl-0.47.0.tgz} 722 722 + engines: {node: ^20.19.0 || >=22.12.0} 723 723 + cpu: [x64] 724 724 + os: [linux] 725 725 + libc: [musl] 726 726 + 727 727 + '@oxfmt/binding-openharmony-arm64@0.47.0': 728 728 + resolution: {integrity: sha512-8r5BDro7fLOBoq1JXHLVSs55OlrxQhEso4HVo0TcY7OXJUPYfjPoOaYL5us+yIwqyP9rQwN+rxuiNFSmaxSuOQ==, tarball: https://registry.npmjs.org/@oxfmt/binding-openharmony-arm64/-/binding-openharmony-arm64-0.47.0.tgz} 729 729 + engines: {node: ^20.19.0 || >=22.12.0} 730 730 + cpu: [arm64] 731 731 + os: [openharmony] 732 732 + 733 733 + '@oxfmt/binding-win32-arm64-msvc@0.47.0': 734 734 + resolution: {integrity: sha512-qtz/gzm8IjSPUlseZ0ofW8zyHLoZsuP5HTfcGGkWkUblB89JT8GNYH3ICqjbDsqsGqXum0/ZndXTFplSdXFIcg==, tarball: https://registry.npmjs.org/@oxfmt/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-0.47.0.tgz} 735 735 + engines: {node: ^20.19.0 || >=22.12.0} 736 736 + cpu: [arm64] 737 737 + os: [win32] 738 738 + 739 739 + '@oxfmt/binding-win32-ia32-msvc@0.47.0': 740 740 + resolution: {integrity: sha512-5vIcdcIDE7nCx+MXN6sm8kbC4zajDB31E86rez4i45iHNH/2NjdKlJ720xcHTr3eeiMcttCGPHPhE1TjtBDGZw==, tarball: https://registry.npmjs.org/@oxfmt/binding-win32-ia32-msvc/-/binding-win32-ia32-msvc-0.47.0.tgz} 741 741 + engines: {node: ^20.19.0 || >=22.12.0} 742 742 + cpu: [ia32] 743 743 + os: [win32] 744 744 + 745 745 + '@oxfmt/binding-win32-x64-msvc@0.47.0': 746 746 + resolution: {integrity: sha512-Sr59Y5ms54ONBjxFeWhVlGyQcHXxcl9DxC23f6yXlRkcos7LXBLoO+KDfxexjHIOZh7cWqrWduzvUjJ+pHp8cQ==, tarball: https://registry.npmjs.org/@oxfmt/binding-win32-x64-msvc/-/binding-win32-x64-msvc-0.47.0.tgz} 747 747 + engines: {node: ^20.19.0 || >=22.12.0} 748 748 + cpu: [x64] 749 749 + os: [win32] 750 750 + 625 751 '@standard-schema/spec@1.1.0': 626 752 resolution: {integrity: sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==, tarball: https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz} 627 753 ··· 867 993 resolution: {integrity: sha512-0eJJY6hXLGf1udHwfNftBqH+g73EU4B504nZeKpz1sYRKafAghwxEJunB2O7rDZkL4PGfsMVnTXZ2EjibbqcsA==, tarball: https://registry.npmjs.org/on-exit-leak-free/-/on-exit-leak-free-2.1.2.tgz} 868 994 engines: {node: '>=14.0.0'} 869 995 996 996 + oxfmt@0.47.0: 997 997 + resolution: {integrity: sha512-OFbkbzxKCpooQEnRmpTDnuwTX8KHXzZTQ4Df/hz85fpS67Pl+lxPEFvUtin56HIIS0B1k4X8oIzTXRZPufA2CA==, tarball: https://registry.npmjs.org/oxfmt/-/oxfmt-0.47.0.tgz} 998 998 + engines: {node: ^20.19.0 || >=22.12.0} 999 999 + hasBin: true 1000 1000 + 870 1001 path-browserify@1.0.1: 871 1002 resolution: {integrity: sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==, tarball: https://registry.npmjs.org/path-browserify/-/path-browserify-1.0.1.tgz} 872 1003 ··· 1002 1133 tinyglobby@0.2.16: 1003 1134 resolution: {integrity: sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg==, tarball: https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.16.tgz} 1004 1135 engines: {node: '>=12.0.0'} 1136 1136 + 1137 1137 + tinypool@2.1.0: 1138 1138 + resolution: {integrity: sha512-Pugqs6M0m7Lv1I7FtxN4aoyToKg1C4tu+/381vH35y8oENM/Ai7f7C4StcoK4/+BSw9ebcS8jRiVrORFKCALLw==, tarball: https://registry.npmjs.org/tinypool/-/tinypool-2.1.0.tgz} 1139 1139 + engines: {node: ^20.0.0 || >=22.0.0} 1005 1140 1006 1141 ts-morph@27.0.2: 1007 1142 resolution: {integrity: sha512-fhUhgeljcrdZ+9DZND1De1029PrE+cMkIP7ooqkLRTrRLTqcki2AstsyJm0vRNbTbVCNJ0idGlbBrfqc7/nA8w==, tarball: https://registry.npmjs.org/ts-morph/-/ts-morph-27.0.2.tgz} ··· 1490 1625 1491 1626 '@noble/hashes@1.8.0': {} 1492 1627 1628 1628 + '@oxfmt/binding-android-arm-eabi@0.47.0': 1629 1629 + optional: true 1630 1630 + 1631 1631 + '@oxfmt/binding-android-arm64@0.47.0': 1632 1632 + optional: true 1633 1633 + 1634 1634 + '@oxfmt/binding-darwin-arm64@0.47.0': 1635 1635 + optional: true 1636 1636 + 1637 1637 + '@oxfmt/binding-darwin-x64@0.47.0': 1638 1638 + optional: true 1639 1639 + 1640 1640 + '@oxfmt/binding-freebsd-x64@0.47.0': 1641 1641 + optional: true 1642 1642 + 1643 1643 + '@oxfmt/binding-linux-arm-gnueabihf@0.47.0': 1644 1644 + optional: true 1645 1645 + 1646 1646 + '@oxfmt/binding-linux-arm-musleabihf@0.47.0': 1647 1647 + optional: true 1648 1648 + 1649 1649 + '@oxfmt/binding-linux-arm64-gnu@0.47.0': 1650 1650 + optional: true 1651 1651 + 1652 1652 + '@oxfmt/binding-linux-arm64-musl@0.47.0': 1653 1653 + optional: true 1654 1654 + 1655 1655 + '@oxfmt/binding-linux-ppc64-gnu@0.47.0': 1656 1656 + optional: true 1657 1657 + 1658 1658 + '@oxfmt/binding-linux-riscv64-gnu@0.47.0': 1659 1659 + optional: true 1660 1660 + 1661 1661 + '@oxfmt/binding-linux-riscv64-musl@0.47.0': 1662 1662 + optional: true 1663 1663 + 1664 1664 + '@oxfmt/binding-linux-s390x-gnu@0.47.0': 1665 1665 + optional: true 1666 1666 + 1667 1667 + '@oxfmt/binding-linux-x64-gnu@0.47.0': 1668 1668 + optional: true 1669 1669 + 1670 1670 + '@oxfmt/binding-linux-x64-musl@0.47.0': 1671 1671 + optional: true 1672 1672 + 1673 1673 + '@oxfmt/binding-openharmony-arm64@0.47.0': 1674 1674 + optional: true 1675 1675 + 1676 1676 + '@oxfmt/binding-win32-arm64-msvc@0.47.0': 1677 1677 + optional: true 1678 1678 + 1679 1679 + '@oxfmt/binding-win32-ia32-msvc@0.47.0': 1680 1680 + optional: true 1681 1681 + 1682 1682 + '@oxfmt/binding-win32-x64-msvc@0.47.0': 1683 1683 + optional: true 1684 1684 + 1493 1685 '@standard-schema/spec@1.1.0': {} 1494 1686 1495 1687 '@ts-morph/common@0.28.1': ··· 1689 1881 1690 1882 on-exit-leak-free@2.1.2: {} 1691 1883 1884 1884 + oxfmt@0.47.0: 1885 1885 + dependencies: 1886 1886 + tinypool: 2.1.0 1887 1887 + optionalDependencies: 1888 1888 + '@oxfmt/binding-android-arm-eabi': 0.47.0 1889 1889 + '@oxfmt/binding-android-arm64': 0.47.0 1890 1890 + '@oxfmt/binding-darwin-arm64': 0.47.0 1891 1891 + '@oxfmt/binding-darwin-x64': 0.47.0 1892 1892 + '@oxfmt/binding-freebsd-x64': 0.47.0 1893 1893 + '@oxfmt/binding-linux-arm-gnueabihf': 0.47.0 1894 1894 + '@oxfmt/binding-linux-arm-musleabihf': 0.47.0 1895 1895 + '@oxfmt/binding-linux-arm64-gnu': 0.47.0 1896 1896 + '@oxfmt/binding-linux-arm64-musl': 0.47.0 1897 1897 + '@oxfmt/binding-linux-ppc64-gnu': 0.47.0 1898 1898 + '@oxfmt/binding-linux-riscv64-gnu': 0.47.0 1899 1899 + '@oxfmt/binding-linux-riscv64-musl': 0.47.0 1900 1900 + '@oxfmt/binding-linux-s390x-gnu': 0.47.0 1901 1901 + '@oxfmt/binding-linux-x64-gnu': 0.47.0 1902 1902 + '@oxfmt/binding-linux-x64-musl': 0.47.0 1903 1903 + '@oxfmt/binding-openharmony-arm64': 0.47.0 1904 1904 + '@oxfmt/binding-win32-arm64-msvc': 0.47.0 1905 1905 + '@oxfmt/binding-win32-ia32-msvc': 0.47.0 1906 1906 + '@oxfmt/binding-win32-x64-msvc': 0.47.0 1907 1907 + 1692 1908 path-browserify@1.0.1: {} 1693 1909 1694 1910 pg-cloudflare@1.3.0: ··· 1820 2036 dependencies: 1821 2037 fdir: 6.5.0(picomatch@4.0.4) 1822 2038 picomatch: 4.0.4 2039 2039 + 2040 2040 + tinypool@2.1.0: {} 1823 2041 1824 2042 ts-morph@27.0.2: 1825 2043 dependencies:

+1 -1

pnpm-workspace.yaml

reviewed

··· 9 9 allowUnusedPatches: true 10 10 lockfileIncludeTarballUrl: true 11 11 patchedDependencies: 12 12 - '@atproto/ws-client': patches/@atproto__ws-client.patch 12 12 + "@atproto/ws-client": patches/@atproto__ws-client.patch

+1 -1

tap/package.json

reviewed

··· 1 1 { 2 2 - "private": true, 3 2 "name": "tap", 3 3 + "private": true, 4 4 "scripts": { 5 5 "dev": "./dev.sh" 6 6 }